mi6_cli/commands/

update_check.rs

//! Background update checking for mi6.
//!
//! Checks for available updates based on the installation method:
//! - GitHub releases: Uses `self_update` crate to check latest release
//! - crates.io: Queries the crates.io API
//! - Homebrew: Runs `brew outdated mi6`
//! - Git source: Checks if the remote has new commits

use std::path::Path;
use std::process::Command;
use std::time::Duration;

use anyhow::{Context, Result};

use super::upgrade::InstallMethod;

/// Information about an available update.
#[derive(Debug, Clone)]
pub struct UpdateInfo {
    /// Current installed version.
    pub current_version: String,
    /// Latest available version.
    pub latest_version: String,
    /// How mi6 was installed.
    pub install_method: String,
    /// Current git commit hash (8 chars) for source installs.
    pub current_git_hash: Option<String>,
}

impl UpdateInfo {
    /// Format user-friendly update notification messages.
    ///
    /// Returns two messages:
    /// 1. "Update available: <current> -> <new>"
    /// 2. "Upgrade using `mi6 upgrade`"
    ///
    /// For source installs, uses 8-character commit hashes.
    /// For other installs, uses version numbers with "v" prefix.
    pub fn notification_messages(&self) -> Vec<String> {
        let (current_display, latest_display) =
            if let Some(ref current_hash) = self.current_git_hash {
                // Source install - show commit hashes (8 chars)
                let latest_hash = self
                    .latest_version
                    .strip_prefix("git:")
                    .unwrap_or(&self.latest_version);
                (current_hash.clone(), latest_hash.to_string())
            } else {
                // Other install - show version numbers with v prefix
                (
                    format!("v{}", self.current_version),
                    format!("v{}", self.latest_version),
                )
            };

        vec![
            format!(
                "Update available: {} -> {}",
                current_display, latest_display
            ),
            "Upgrade using `mi6 upgrade`".to_string(),
        ]
    }
}

/// Check for available updates based on installation method.
///
/// Returns `Ok(Some(UpdateInfo))` if an update is available,
/// `Ok(None)` if already at the latest version,
/// or an error if the check failed.
///
/// This function is designed to be called from a background thread
/// and should not block the main thread for long.
pub fn check_for_update() -> Result<Option<UpdateInfo>> {
    let current_version = env!("CARGO_PKG_VERSION");
    let install_method = InstallMethod::detect()?;

    check_for_update_with_method(current_version, &install_method)
}

/// Check for updates with explicit version and install method.
/// Useful for testing or when these are already known.
pub fn check_for_update_with_method(
    current_version: &str,
    install_method: &InstallMethod,
) -> Result<Option<UpdateInfo>> {
    let method_name = install_method.name().to_string();

    match install_method {
        InstallMethod::Standalone => check_github_releases(current_version, &method_name),
        InstallMethod::CargoRegistry => check_crates_io(current_version, &method_name),
        InstallMethod::Homebrew => check_homebrew(current_version, &method_name),
        InstallMethod::CargoPath(path) => check_git_source(current_version, path, &method_name),
    }
}

/// Check GitHub releases for updates using the self_update crate.
fn check_github_releases(current_version: &str, method_name: &str) -> Result<Option<UpdateInfo>> {
    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 GitHub update checker")?;

    let latest = update
        .get_latest_release()
        .context("failed to check GitHub releases")?;

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

    if is_newer_version(&latest_version, current_version) {
        Ok(Some(UpdateInfo {
            current_version: current_version.to_string(),
            latest_version,
            install_method: method_name.to_string(),
            current_git_hash: None,
        }))
    } else {
        Ok(None)
    }
}

/// crates.io API response for crate info.
#[derive(serde::Deserialize)]
struct CratesIoResponse {
    #[serde(rename = "crate")]
    crate_info: CrateInfo,
}

#[derive(serde::Deserialize)]
struct CrateInfo {
    max_stable_version: String,
}

/// Check crates.io for updates.
fn check_crates_io(current_version: &str, method_name: &str) -> Result<Option<UpdateInfo>> {
    // crates.io API requires a User-Agent header
    let response = ureq::get("https://crates.io/api/v1/crates/mi6")
        .set(
            "User-Agent",
            &format!(
                "mi6/{} (https://github.com/paradigmxyz/mi6)",
                current_version
            ),
        )
        .timeout(Duration::from_secs(10))
        .call()
        .context("failed to query crates.io API")?;

    let body: CratesIoResponse = response
        .into_json()
        .context("failed to parse crates.io response")?;

    let latest_version = body.crate_info.max_stable_version;

    if is_newer_version(&latest_version, current_version) {
        Ok(Some(UpdateInfo {
            current_version: current_version.to_string(),
            latest_version,
            install_method: method_name.to_string(),
            current_git_hash: None,
        }))
    } else {
        Ok(None)
    }
}

/// Check Homebrew for updates.
fn check_homebrew(current_version: &str, method_name: &str) -> Result<Option<UpdateInfo>> {
    let output = Command::new("brew")
        .args(["info", "--json=v2", "mi6"])
        .output()
        .context("failed to run brew info")?;

    if !output.status.success() {
        // If brew info fails, silently skip the check rather than adding fallback complexity
        return Ok(None);
    }

    let stdout = String::from_utf8_lossy(&output.stdout);

    // Parse the JSON response to get the latest version
    #[derive(serde::Deserialize)]
    struct BrewInfoResponse {
        formulae: Vec<BrewFormula>,
    }

    #[derive(serde::Deserialize)]
    struct BrewFormula {
        versions: BrewVersions,
    }

    #[derive(serde::Deserialize)]
    struct BrewVersions {
        stable: String,
    }

    let info: BrewInfoResponse =
        serde_json::from_str(&stdout).context("failed to parse brew info JSON")?;

    let latest_version = info
        .formulae
        .first()
        .map(|f| f.versions.stable.clone())
        .unwrap_or_default();

    if latest_version.is_empty() {
        return Ok(None);
    }

    if is_newer_version(&latest_version, current_version) {
        Ok(Some(UpdateInfo {
            current_version: current_version.to_string(),
            latest_version,
            install_method: method_name.to_string(),
            current_git_hash: None,
        }))
    } else {
        Ok(None)
    }
}

/// Check git source for updates by comparing installed binary with local source.
///
/// This checks two things:
/// 1. If the installed binary is older than the local source (primary check)
/// 2. If the local source is behind the remote (secondary check)
fn check_git_source(
    current_version: &str,
    path: &Path,
    method_name: &str,
) -> Result<Option<UpdateInfo>> {
    let path_str = path.to_string_lossy();

    // First, fetch from remote with a timeout to avoid blocking.
    // Use git config options to timeout if transfer is too slow:
    // - lowSpeedLimit: minimum bytes/sec (1000 = 1KB/s)
    // - lowSpeedTime: seconds to wait at low speed before aborting (5s)
    let fetch_output = Command::new("git")
        .args([
            "-C",
            &path_str,
            "-c",
            "http.lowSpeedLimit=1000",
            "-c",
            "http.lowSpeedTime=5",
            "fetch",
            "--quiet",
        ])
        .output();

    // Ignore fetch errors - we'll just compare with whatever remote state we have
    // Remote might not be reachable, which is fine
    let _ = fetch_output;

    // Get local HEAD commit
    let local_output = Command::new("git")
        .args(["-C", &path_str, "rev-parse", "HEAD"])
        .output()
        .context("failed to get local HEAD")?;

    if !local_output.status.success() {
        anyhow::bail!("git rev-parse HEAD failed");
    }

    let local_head = String::from_utf8_lossy(&local_output.stdout)
        .trim()
        .to_string();
    let local_short = &local_head[..8.min(local_head.len())];

    // Check if installed binary is behind local source
    // The installed binary's git commit is embedded at compile time
    let installed_commit = option_env!("MI6_GIT_COMMIT").filter(|s| !s.is_empty());

    if let Some(installed) = installed_commit {
        // If installed commit doesn't match local HEAD, check if local is ahead
        if !local_head.starts_with(installed) {
            // Check if installed commit is an ancestor of local HEAD
            // (i.e., local HEAD is newer than the installed binary)
            let is_ancestor = Command::new("git")
                .args([
                    "-C",
                    &path_str,
                    "merge-base",
                    "--is-ancestor",
                    installed,
                    &local_head,
                ])
                .status()
                .map(|s| s.success())
                .unwrap_or(false);

            if is_ancestor {
                return Ok(Some(UpdateInfo {
                    current_version: current_version.to_string(),
                    latest_version: format!("git:{}", local_short),
                    install_method: method_name.to_string(),
                    current_git_hash: Some(installed.to_string()),
                }));
            }
        }
    }

    // Also check if remote is ahead of local (user may need to pull first)
    let remote_branch = find_default_remote_branch(path)?;
    let remote_output = Command::new("git")
        .args(["-C", &path_str, "rev-parse", &remote_branch])
        .output()
        .context("failed to get remote HEAD")?;

    if !remote_output.status.success() {
        anyhow::bail!("git rev-parse {} failed", remote_branch);
    }

    let remote_head = String::from_utf8_lossy(&remote_output.stdout)
        .trim()
        .to_string();

    // If local and remote differ, check if remote is ahead
    if local_head != remote_head {
        // Check if remote is ahead of local
        let merge_base_output = Command::new("git")
            .args(["-C", &path_str, "merge-base", &local_head, &remote_head])
            .output()
            .context("failed to find merge base")?;

        if merge_base_output.status.success() {
            let merge_base = String::from_utf8_lossy(&merge_base_output.stdout)
                .trim()
                .to_string();

            // Remote is ahead if merge base equals local HEAD
            if merge_base == local_head {
                let remote_short = &remote_head[..8.min(remote_head.len())];
                return Ok(Some(UpdateInfo {
                    current_version: current_version.to_string(),
                    latest_version: format!("git:{}", remote_short),
                    install_method: method_name.to_string(),
                    current_git_hash: Some(local_short.to_string()),
                }));
            }
        }
    }

    Ok(None)
}

/// Find the default remote branch (origin/main or origin/master).
fn find_default_remote_branch(path: &Path) -> Result<String> {
    let path_str = path.to_string_lossy();

    // Try origin/main first
    let main_check = Command::new("git")
        .args(["-C", &path_str, "rev-parse", "--verify", "origin/main"])
        .output();

    if let Ok(output) = main_check
        && output.status.success()
    {
        return Ok("origin/main".to_string());
    }

    // Fall back to origin/master
    let master_check = Command::new("git")
        .args(["-C", &path_str, "rev-parse", "--verify", "origin/master"])
        .output();

    if let Ok(output) = master_check
        && output.status.success()
    {
        return Ok("origin/master".to_string());
    }

    // Default to origin/main if neither exists (will fail later with a clear error)
    Ok("origin/main".to_string())
}

/// Compare two semantic versions to check if `latest` is newer than `current`.
///
/// Handles pre-release versions: stable releases are considered newer than
/// pre-release versions of the same base version (e.g., 1.0.0 > 1.0.0-alpha).
fn is_newer_version(latest: &str, current: &str) -> bool {
    // Split version into base parts and whether it has a pre-release suffix
    let parse_version = |v: &str| -> (Vec<u32>, bool) {
        let mut parts = Vec::new();
        let mut has_prerelease = false;

        for segment in v.split('.') {
            // Check if this segment has a pre-release suffix
            if let Some(dash_pos) = segment.find('-') {
                let num_part = &segment[..dash_pos];
                if let Ok(n) = num_part.parse() {
                    parts.push(n);
                }
                has_prerelease = true;
            } else if let Ok(n) = segment.parse() {
                parts.push(n);
            }
        }
        (parts, has_prerelease)
    };

    let (latest_parts, latest_is_prerelease) = parse_version(latest);
    let (current_parts, current_is_prerelease) = parse_version(current);

    // Compare numeric parts first
    for (l, c) in latest_parts.iter().zip(current_parts.iter()) {
        match l.cmp(c) {
            std::cmp::Ordering::Greater => return true,
            std::cmp::Ordering::Less => return false,
            std::cmp::Ordering::Equal => {}
        }
    }

    // If one version has more parts, check those
    if latest_parts.len() != current_parts.len() {
        return latest_parts.len() > current_parts.len();
    }

    // Same base version - check pre-release status
    // A stable release (no prerelease) is newer than a prerelease
    // e.g., 1.0.0 > 1.0.0-alpha
    match (latest_is_prerelease, current_is_prerelease) {
        (false, true) => true,  // latest is stable, current is prerelease
        (true, false) => false, // latest is prerelease, current is stable
        _ => false,             // both same type, not newer
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_is_newer_version() {
        // Basic version comparisons
        assert!(is_newer_version("1.0.1", "1.0.0"));
        assert!(is_newer_version("1.1.0", "1.0.0"));
        assert!(is_newer_version("2.0.0", "1.0.0"));

        // Same version
        assert!(!is_newer_version("1.0.0", "1.0.0"));

        // Older version
        assert!(!is_newer_version("1.0.0", "1.0.1"));
        assert!(!is_newer_version("1.0.0", "2.0.0"));

        // Version with more parts
        assert!(is_newer_version("1.0.1", "1.0"));
        assert!(!is_newer_version("1.0", "1.0.1"));

        // Pre-release versions - newer major/minor/patch wins
        assert!(is_newer_version("1.0.1", "1.0.0-alpha"));
        assert!(!is_newer_version("1.0.0-alpha", "1.0.1"));

        // Pre-release to stable of SAME version - stable is newer
        // This is the key edge case from the review
        assert!(is_newer_version("1.0.0", "1.0.0-alpha"));
        assert!(is_newer_version("1.0.0", "1.0.0-beta"));
        assert!(is_newer_version("1.0.0", "1.0.0-rc1"));

        // Stable to pre-release of same version - not newer
        assert!(!is_newer_version("1.0.0-alpha", "1.0.0"));

        // Same pre-release is not newer
        assert!(!is_newer_version("1.0.0-alpha", "1.0.0-alpha"));
    }

    #[test]
    fn test_update_info_notification_messages() {
        // Test non-source install (version numbers)
        let info = UpdateInfo {
            current_version: "1.0.0".to_string(),
            latest_version: "1.1.0".to_string(),
            install_method: "Standalone".to_string(),
            current_git_hash: None,
        };
        let messages = info.notification_messages();
        assert_eq!(messages.len(), 2);
        assert_eq!(messages[0], "Update available: v1.0.0 -> v1.1.0");
        assert_eq!(messages[1], "Upgrade using `mi6 upgrade`");

        // Test source install (commit hashes)
        let info_source = UpdateInfo {
            current_version: "1.0.0".to_string(),
            latest_version: "git:b697acb1".to_string(),
            install_method: "Cargo (source)".to_string(),
            current_git_hash: Some("a1b2c3d4".to_string()),
        };
        let messages_source = info_source.notification_messages();
        assert_eq!(messages_source.len(), 2);
        assert_eq!(messages_source[0], "Update available: a1b2c3d4 -> b697acb1");
        assert_eq!(messages_source[1], "Upgrade using `mi6 upgrade`");
    }
}