xbp_cli/commands/

update.rs

//! Check for newer XBP releases on crates.io (and optionally install them).

use crate::cli::ui::{self, status_line, tip, Loader};
use colored::Colorize;
use semver::Version;
use serde::Deserialize;
use serde_json::json;
use std::process::Command;

const CRATE_PAGE_URL: &str = "https://crates.io/crates/xbp";
const CRATES_IO_API_URL: &str = "https://crates.io/api/v1/crates";
const DEFAULT_CRATE_NAME: &str = "xbp";
/// Default Cargo features for `xbp update --install` when the user does not pass `--features`.
const DEFAULT_INSTALL_FEATURES: &[&str] = &["all"];
const USER_AGENT: &str = concat!(
    "xbp/",
    env!("CARGO_PKG_VERSION"),
    " (+https://github.com/xylex-group/xbp)"
);

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UpdateStatus {
    UpToDate,
    UpdateAvailable,
    LocalNewer,
    Unknown,
}

impl UpdateStatus {
    fn as_str(self) -> &'static str {
        match self {
            Self::UpToDate => "up_to_date",
            Self::UpdateAvailable => "update_available",
            Self::LocalNewer => "local_newer",
            Self::Unknown => "unknown",
        }
    }

    fn label(self) -> &'static str {
        match self {
            Self::UpToDate => "up to date",
            Self::UpdateAvailable => "update available",
            Self::LocalNewer => "local is newer",
            Self::Unknown => "unknown",
        }
    }
}

#[derive(Debug, Clone)]
pub struct UpdateCheckResult {
    pub crate_name: String,
    pub current_version: String,
    pub latest_version: String,
    pub published_at: Option<String>,
    pub crate_url: String,
    pub status: UpdateStatus,
    pub install_command: String,
}

/// Feature selection passed through to `cargo install`.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct InstallFeaturePlan {
    pub features: Vec<String>,
    pub no_default_features: bool,
    pub all_features: bool,
}

impl InstallFeaturePlan {
    /// Resolve install features: bare `--install` defaults to `--features all`.
    pub fn resolve(
        features: &[String],
        no_default_features: bool,
        all_features: bool,
    ) -> Self {
        let mut normalized = Vec::new();
        for feature in features {
            for part in feature.split([',', ' ']) {
                let part = part.trim();
                if !part.is_empty() && !normalized.iter().any(|existing| existing == part) {
                    normalized.push(part.to_string());
                }
            }
        }

        if all_features {
            return Self {
                features: Vec::new(),
                no_default_features,
                all_features: true,
            };
        }

        if normalized.is_empty() && !no_default_features {
            normalized = DEFAULT_INSTALL_FEATURES
                .iter()
                .map(|value| (*value).to_string())
                .collect();
        }

        Self {
            features: normalized,
            no_default_features,
            all_features: false,
        }
    }

    pub fn append_cargo_args(&self, args: &mut Vec<String>) {
        if self.no_default_features {
            args.push("--no-default-features".to_string());
        }
        if self.all_features {
            args.push("--all-features".to_string());
            return;
        }
        if !self.features.is_empty() {
            args.push("--features".to_string());
            args.push(self.features.join(","));
        }
    }

    pub fn command_suffix(&self) -> String {
        let mut parts = Vec::new();
        if self.no_default_features {
            parts.push("--no-default-features".to_string());
        }
        if self.all_features {
            parts.push("--all-features".to_string());
        } else if !self.features.is_empty() {
            parts.push(format!("--features {}", self.features.join(",")));
        }
        parts.join(" ")
    }
}

#[derive(Debug, Deserialize)]
struct CratesIoCrateResponse {
    #[serde(rename = "crate")]
    crate_meta: CratesIoCrateMeta,
    #[serde(default)]
    versions: Vec<CratesIoVersionEntry>,
}

#[derive(Debug, Deserialize)]
struct CratesIoCrateMeta {
    newest_version: String,
    #[serde(default)]
    max_stable_version: Option<String>,
}

#[derive(Debug, Deserialize)]
struct CratesIoVersionEntry {
    num: String,
    #[serde(default)]
    created_at: Option<String>,
    #[serde(default)]
    yanked: bool,
}

#[derive(Debug, Clone)]
pub struct UpdateCheckOptions {
    pub crate_name: String,
    pub json: bool,
    pub install: bool,
    pub features: Vec<String>,
    pub no_default_features: bool,
    pub all_features: bool,
    pub fail_if_outdated: bool,
}

impl Default for UpdateCheckOptions {
    fn default() -> Self {
        Self {
            crate_name: DEFAULT_CRATE_NAME.to_string(),
            json: false,
            install: false,
            features: Vec::new(),
            no_default_features: false,
            all_features: false,
            fail_if_outdated: false,
        }
    }
}

pub async fn run_update_check(options: UpdateCheckOptions) -> Result<(), String> {
    let crate_name = normalize_crate_name(&options.crate_name)?;
    let current_version = env!("CARGO_PKG_VERSION").to_string();
    let feature_plan = InstallFeaturePlan::resolve(
        &options.features,
        options.no_default_features,
        options.all_features,
    );

    let loader = if options.json {
        None
    } else {
        Some(Loader::start(&format!(
            "Checking crates.io for {crate_name}"
        )))
    };

    let result = match check_for_update(&crate_name, &current_version, &feature_plan).await {
        Ok(result) => {
            if let Some(loader) = &loader {
                loader.success_with(&format!(
                    "latest {} ({})",
                    result.latest_version,
                    result.status.label()
                ));
            }
            result
        }
        Err(error) => {
            if let Some(loader) = &loader {
                loader.fail("lookup failed");
            }
            return Err(error);
        }
    };

    if options.json {
        println!(
            "{}",
            serde_json::to_string_pretty(&json!({
                "crate": result.crate_name,
                "current_version": result.current_version,
                "latest_version": result.latest_version,
                "published_at": result.published_at,
                "status": result.status.as_str(),
                "update_available": result.status == UpdateStatus::UpdateAvailable,
                "crate_url": result.crate_url,
                "install_command": result.install_command,
                "features": feature_plan.features,
                "no_default_features": feature_plan.no_default_features,
                "all_features": feature_plan.all_features,
            }))
            .map_err(|error| format!("Failed to serialize update check result: {error}"))?
        );
    } else {
        print_update_report(&result, options.install.then_some(&feature_plan));
    }

    if options.install {
        if result.status == UpdateStatus::UpdateAvailable {
            run_cargo_install(&result.crate_name, &result.latest_version, &feature_plan)?;
        } else if !options.json {
            tip("Nothing to install; local CLI is already current (or newer than crates.io).");
        }
    }

    if options.fail_if_outdated && result.status == UpdateStatus::UpdateAvailable {
        return Err(format!(
            "Update available: {} -> {} (crates.io/{})",
            result.current_version, result.latest_version, result.crate_name
        ));
    }

    Ok(())
}

pub async fn check_for_update(
    crate_name: &str,
    current_version: &str,
    feature_plan: &InstallFeaturePlan,
) -> Result<UpdateCheckResult, String> {
    let latest = fetch_crates_io_latest(crate_name).await?;
    let status = compare_versions(current_version, &latest.version);
    let mut install_command = format!("cargo install {crate_name} --locked");
    let suffix = feature_plan.command_suffix();
    if !suffix.is_empty() {
        install_command.push(' ');
        install_command.push_str(&suffix);
    }
    Ok(UpdateCheckResult {
        crate_name: crate_name.to_string(),
        current_version: current_version.to_string(),
        latest_version: latest.version.clone(),
        published_at: latest.published_at,
        crate_url: format!("https://crates.io/crates/{crate_name}"),
        status,
        install_command,
    })
}

fn print_update_report(result: &UpdateCheckResult, feature_plan: Option<&InstallFeaturePlan>) {
    ui::configure_color_output();
    println!();
    println!(
        "{} {}",
        "XBP".bright_magenta().bold(),
        "update check".bright_white().bold()
    );
    ui::divider(56);

    status_line("Crate", &result.crate_name, true);
    status_line("Installed", &format!("v{}", result.current_version), true);

    let latest_ok = matches!(
        result.status,
        UpdateStatus::UpToDate | UpdateStatus::LocalNewer
    );
    status_line(
        "crates.io latest",
        &format!("v{}", result.latest_version),
        latest_ok,
    );

    if let Some(published_at) = result.published_at.as_deref() {
        status_line("Published", published_at, true);
    }

    if let Some(plan) = feature_plan {
        let features_label = if plan.all_features {
            "all-features".to_string()
        } else if plan.features.is_empty() {
            if plan.no_default_features {
                "(none)".to_string()
            } else {
                "(package defaults)".to_string()
            }
        } else {
            plan.features.join(", ")
        };
        status_line("Install features", &features_label, true);
        if plan.no_default_features {
            status_line("Default features", "disabled", true);
        }
    }

    let (status_text, status_ok) = match result.status {
        UpdateStatus::UpToDate => ("up to date".to_string(), true),
        UpdateStatus::UpdateAvailable => (
            format!(
                "update available (v{} → v{})",
                result.current_version, result.latest_version
            ),
            false,
        ),
        UpdateStatus::LocalNewer => (
            format!(
                "local is newer than crates.io (v{} > v{})",
                result.current_version, result.latest_version
            ),
            true,
        ),
        UpdateStatus::Unknown => (
            "could not compare versions (non-semver?)".to_string(),
            false,
        ),
    };
    status_line("Status", &status_text, status_ok);
    ui::divider(56);

    match result.status {
        UpdateStatus::UpdateAvailable => {
            tip(&format!("Upgrade with `{}`", result.install_command));
            tip(&format!("Or open {}", result.crate_url));
            if result.crate_name == DEFAULT_CRATE_NAME {
                tip("Quick install: `xbp update --install` (defaults to --features all)");
            }
        }
        UpdateStatus::UpToDate => {
            tip(&format!("You are on the latest release from {CRATE_PAGE_URL}."));
        }
        UpdateStatus::LocalNewer => {
            tip("This binary is ahead of the published crates.io release (dev build or unpublished bump).");
        }
        UpdateStatus::Unknown => {
            tip(&format!("Inspect releases at {}", result.crate_url));
        }
    }
}

async fn fetch_crates_io_latest(crate_name: &str) -> Result<LatestRelease, String> {
    let client = reqwest::Client::builder()
        .user_agent(USER_AGENT)
        .build()
        .map_err(|error| format!("Failed to build HTTP client: {error}"))?;

    let url = format!("{CRATES_IO_API_URL}/{crate_name}");
    let response = client
        .get(&url)
        .send()
        .await
        .map_err(|error| format!("Failed to query crates.io for `{crate_name}`: {error}"))?;

    if !response.status().is_success() {
        return Err(format!(
            "crates.io lookup for `{crate_name}` returned HTTP {}.",
            response.status().as_u16()
        ));
    }

    let payload: CratesIoCrateResponse = response
        .json()
        .await
        .map_err(|error| format!("Failed to parse crates.io response for `{crate_name}`: {error}"))?;

    // Prefer the declared newest version; fall back to max stable if present.
    let latest_version = payload
        .crate_meta
        .max_stable_version
        .filter(|value| !value.trim().is_empty())
        .unwrap_or(payload.crate_meta.newest_version);

    if latest_version.trim().is_empty() {
        return Err(format!(
            "crates.io response for `{crate_name}` did not include a latest version."
        ));
    }

    let published_at = payload
        .versions
        .iter()
        .find(|entry| entry.num == latest_version && !entry.yanked)
        .and_then(|entry| entry.created_at.clone())
        .or_else(|| {
            payload
                .versions
                .iter()
                .find(|entry| entry.num == latest_version)
                .and_then(|entry| entry.created_at.clone())
        });

    Ok(LatestRelease {
        version: latest_version,
        published_at,
    })
}

struct LatestRelease {
    version: String,
    published_at: Option<String>,
}

fn compare_versions(current: &str, latest: &str) -> UpdateStatus {
    let Ok(current) = Version::parse(current.trim().trim_start_matches('v')) else {
        return UpdateStatus::Unknown;
    };
    let Ok(latest) = Version::parse(latest.trim().trim_start_matches('v')) else {
        return UpdateStatus::Unknown;
    };

    match current.cmp(&latest) {
        std::cmp::Ordering::Less => UpdateStatus::UpdateAvailable,
        std::cmp::Ordering::Equal => UpdateStatus::UpToDate,
        std::cmp::Ordering::Greater => UpdateStatus::LocalNewer,
    }
}

fn normalize_crate_name(name: &str) -> Result<String, String> {
    let trimmed = name.trim();
    if trimmed.is_empty() {
        return Err("Crate name must not be empty.".to_string());
    }
    if !trimmed
        .chars()
        .all(|ch| ch.is_ascii_alphanumeric() || ch == '-' || ch == '_')
    {
        return Err(format!(
            "Invalid crate name `{trimmed}`. Use letters, digits, `-`, or `_`."
        ));
    }
    Ok(trimmed.to_string())
}

fn run_cargo_install(
    crate_name: &str,
    version: &str,
    feature_plan: &InstallFeaturePlan,
) -> Result<(), String> {
    if which_cargo().is_none() {
        return Err(
            "`cargo` was not found on PATH. Install Rust from https://rustup.rs then re-run `xbp update --install`."
                .to_string(),
        );
    }

    // Release worktree-watch (parent/repos + tray) before cargo tries to replace
    // the installed binary — otherwise Windows holds a file claim on xbp.exe.
    if crate_name == DEFAULT_CRATE_NAME {
        crate::commands::worktree_watch::stop_active_worktree_watch_before_install();
        crate::commands::worktree_watch_tray::stop_worktree_watch_tray_before_install();
    }

    let mut args = vec![
        "install".to_string(),
        crate_name.to_string(),
        "--locked".to_string(),
        "--version".to_string(),
        version.to_string(),
        "--force".to_string(),
    ];
    feature_plan.append_cargo_args(&mut args);
    let display = format!("cargo {}", args.join(" "));

    println!();
    println!(
        "{} {}",
        "Installing".bright_cyan().bold(),
        format!("{crate_name}@{version}").bright_white()
    );
    if !feature_plan.command_suffix().is_empty() {
        status_line("Features", &feature_plan.command_suffix(), true);
    }
    tip(&format!("Running `{display}`"));

    let status = Command::new("cargo")
        .args(&args)
        .status()
        .map_err(|error| format!("Failed to spawn `cargo install`: {error}"))?;

    if !status.success() {
        return Err(format!("`{display}` failed with status {status}."));
    }

    println!(
        "{} {}",
        "OK".bright_green().bold(),
        format!("Installed {crate_name}@{version}").bright_white()
    );
    Ok(())
}

fn which_cargo() -> Option<std::path::PathBuf> {
    crate::utils::command_exists("cargo").then(|| std::path::PathBuf::from("cargo"))
}

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

    #[test]
    fn compares_semver_update_states() {
        assert_eq!(
            compare_versions("10.37.0", "10.38.0"),
            UpdateStatus::UpdateAvailable
        );
        assert_eq!(
            compare_versions("10.38.0", "10.38.0"),
            UpdateStatus::UpToDate
        );
        assert_eq!(
            compare_versions("10.38.1", "10.38.0"),
            UpdateStatus::LocalNewer
        );
        assert_eq!(compare_versions("not-a-version", "1.0.0"), UpdateStatus::Unknown);
    }

    #[test]
    fn normalizes_crate_names() {
        assert_eq!(normalize_crate_name("xbp").unwrap(), "xbp");
        assert!(normalize_crate_name("").is_err());
        assert!(normalize_crate_name("evil/name").is_err());
    }

    #[test]
    fn install_features_default_to_all() {
        let plan = InstallFeaturePlan::resolve(&[], false, false);
        assert_eq!(plan.features, vec!["all".to_string()]);
        assert!(!plan.all_features);
        assert!(!plan.no_default_features);
        assert_eq!(plan.command_suffix(), "--features all");
    }

    #[test]
    fn install_features_respect_explicit_list() {
        let plan = InstallFeaturePlan::resolve(
            &["secrets".to_string(), "docker,linear".to_string()],
            false,
            false,
        );
        assert_eq!(
            plan.features,
            vec![
                "secrets".to_string(),
                "docker".to_string(),
                "linear".to_string()
            ]
        );
        let mut args = Vec::new();
        plan.append_cargo_args(&mut args);
        assert_eq!(
            args,
            vec!["--features".to_string(), "secrets,docker,linear".to_string()]
        );
    }

    #[test]
    fn install_features_all_features_flag_wins() {
        let plan = InstallFeaturePlan::resolve(&["secrets".to_string()], true, true);
        assert!(plan.all_features);
        assert!(plan.no_default_features);
        assert!(plan.features.is_empty());
        assert_eq!(
            plan.command_suffix(),
            "--no-default-features --all-features"
        );
    }

    #[test]
    fn install_features_no_default_without_list_skips_all() {
        let plan = InstallFeaturePlan::resolve(&[], true, false);
        assert!(plan.features.is_empty());
        assert!(plan.no_default_features);
        assert_eq!(plan.command_suffix(), "--no-default-features");
    }
}