st/

updater.rs

// -----------------------------------------------------------------------------
// Self-Update Module for Smart Tree
// Checks for updates from GitHub releases and installs new versions
// -----------------------------------------------------------------------------

use anyhow::{bail, Context, Result};
use serde::{Deserialize, Serialize};
use std::env;
use std::fs;
use std::io::{self, Write};
use std::path::{Path, PathBuf};
use std::process::Command;
use std::time::{Duration, SystemTime, UNIX_EPOCH};

/// GitHub repository for releases
const GITHUB_REPO: &str = "8b-is/smart-tree";

/// GitHub API endpoint for latest release
const GITHUB_RELEASES_API: &str = "https://api.github.com/repos/8b-is/smart-tree/releases/latest";

/// Rate limit: check for updates at most once per 24 hours
const UPDATE_CHECK_INTERVAL_SECS: u64 = 86400;

/// Binaries included in the release tarball
/// Note: "n8x" replaces "tree" to avoid shadowing the real tree command
const BINARIES: &[&str] = &["st", "mq", "m8", "n8x"];

/// Current version from Cargo.toml
const CURRENT_VERSION: &str = env!("CARGO_PKG_VERSION");

/// GitHub release response (partial)
#[derive(Debug, Deserialize)]
struct GitHubRelease {
    tag_name: String,
    assets: Vec<GitHubAsset>,
}

#[derive(Debug, Deserialize)]
struct GitHubAsset {
    name: String,
    browser_download_url: String,
}

/// Update check cache
#[derive(Debug, Default, Serialize, Deserialize)]
struct UpdateCache {
    #[serde(default)]
    last_check: u64,
    #[serde(default)]
    latest_version: Option<String>,
}

/// Get the cache file path (~/.st/update_check.json)
fn get_cache_path() -> Result<PathBuf> {
    let home = dirs::home_dir().context("Could not find home directory")?;
    let st_dir = home.join(".st");
    fs::create_dir_all(&st_dir)?;
    Ok(st_dir.join("update_check.json"))
}

/// Load the update cache
fn load_cache() -> UpdateCache {
    let cache_path = match get_cache_path() {
        Ok(p) => p,
        Err(_) => return UpdateCache::default(),
    };

    match fs::read_to_string(&cache_path) {
        Ok(contents) => serde_json::from_str(&contents).unwrap_or_default(),
        Err(_) => UpdateCache::default(),
    }
}

/// Save the update cache
fn save_cache(cache: &UpdateCache) -> Result<()> {
    let cache_path = get_cache_path()?;
    let contents = serde_json::to_string_pretty(cache)?;
    fs::write(&cache_path, contents)?;
    Ok(())
}

/// Get current timestamp in seconds
fn now_secs() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|d| d.as_secs())
        .unwrap_or(0)
}

/// Check if we should perform an update check (rate limiting)
pub fn should_check_update() -> bool {
    let cache = load_cache();
    let now = now_secs();
    now.saturating_sub(cache.last_check) > UPDATE_CHECK_INTERVAL_SECS
}

/// Compare version strings (semver-like)
fn is_newer_version(current: &str, latest: &str) -> bool {
    // Strip 'v' prefix if present
    let current = current.strip_prefix('v').unwrap_or(current);
    let latest = latest.strip_prefix('v').unwrap_or(latest);

    let parse_version = |v: &str| -> (u32, u32, u32) {
        let parts: Vec<u32> = v.split('.').filter_map(|p| p.parse().ok()).collect();
        (
            parts.first().copied().unwrap_or(0),
            parts.get(1).copied().unwrap_or(0),
            parts.get(2).copied().unwrap_or(0),
        )
    };

    let (curr_major, curr_minor, curr_patch) = parse_version(current);
    let (lat_major, lat_minor, lat_patch) = parse_version(latest);

    (lat_major, lat_minor, lat_patch) > (curr_major, curr_minor, curr_patch)
}

/// Check for available updates (network call) - async version
pub async fn check_for_update() -> Result<Option<String>> {
    let client = reqwest::Client::builder()
        .user_agent("smart-tree-updater")
        .timeout(Duration::from_secs(10))
        .build()?;

    let response: GitHubRelease = client
        .get(GITHUB_RELEASES_API)
        .send()
        .await
        .context("Failed to connect to GitHub")?
        .json()
        .await
        .context("Failed to parse GitHub response")?;

    // Update cache
    let mut cache = load_cache();
    cache.last_check = now_secs();
    cache.latest_version = Some(response.tag_name.clone());
    let _ = save_cache(&cache);

    let latest = response.tag_name;
    if is_newer_version(CURRENT_VERSION, &latest) {
        Ok(Some(latest))
    } else {
        Ok(None)
    }
}

/// Check for update using cache if within rate limit - async version
pub async fn check_for_update_cached() -> Option<String> {
    let cache = load_cache();

    if should_check_update() {
        // Perform actual check
        match check_for_update().await {
            Ok(Some(version)) => Some(version),
            Ok(None) => None,
            Err(_) => None, // Silently fail on network errors
        }
    } else {
        // Use cached result
        cache
            .latest_version
            .filter(|v| is_newer_version(CURRENT_VERSION, v))
    }
}

/// Print update available banner
pub fn print_update_banner(latest_version: &str) {
    let current = format!("v{}", CURRENT_VERSION);
    eprintln!();
    eprintln!("\x1b[36m╭─────────────────────────────────────────────────────╮\x1b[0m");
    eprintln!(
        "\x1b[36m│\x1b[0m \x1b[32m🌳 Smart Tree {} is available!\x1b[0m (you have {})",
        latest_version, current
    );
    eprintln!("\x1b[36m│\x1b[0m    Run '\x1b[1mst --update\x1b[0m' to upgrade");
    eprintln!("\x1b[36m╰─────────────────────────────────────────────────────╯\x1b[0m");
    eprintln!();
}

/// Detect the current platform for download
fn get_platform() -> Result<(&'static str, &'static str)> {
    let os = if cfg!(target_os = "macos") {
        "apple-darwin"
    } else if cfg!(target_os = "linux") {
        "unknown-linux-gnu"
    } else if cfg!(target_os = "windows") {
        "pc-windows-msvc"
    } else {
        bail!("Unsupported operating system");
    };

    let arch = if cfg!(target_arch = "x86_64") {
        "x86_64"
    } else if cfg!(target_arch = "aarch64") {
        "aarch64"
    } else {
        bail!("Unsupported architecture");
    };

    Ok((arch, os))
}

/// Create a temporary directory for the update
fn create_temp_dir() -> Result<PathBuf> {
    let base = env::temp_dir();
    let unique_name = format!("st-update-{}", now_secs());
    let temp_dir = base.join(unique_name);
    fs::create_dir_all(&temp_dir).context("Failed to create temp directory")?;
    Ok(temp_dir)
}

/// Clean up a temporary directory
fn cleanup_temp_dir(path: &Path) {
    let _ = fs::remove_dir_all(path);
}

/// Find where the current binary is installed
fn find_install_dir() -> Result<PathBuf> {
    // Try to find where 'st' is installed
    let current_exe = env::current_exe().context("Could not determine current executable path")?;
    let install_dir = current_exe
        .parent()
        .context("Could not determine installation directory")?
        .to_path_buf();

    Ok(install_dir)
}

/// Check if we need elevated permissions
fn needs_sudo(install_dir: &Path) -> bool {
    #[cfg(unix)]
    {
        use std::os::unix::fs::MetadataExt;
        if let Ok(meta) = install_dir.metadata() {
            // Check if we're the owner or if we can write
            let uid = unsafe { libc::getuid() };
            if meta.uid() != uid {
                // Not owner, check if writable
                return fs::metadata(install_dir)
                    .and_then(|_| {
                        fs::OpenOptions::new()
                            .write(true)
                            .open(install_dir.join(".test_write"))
                    })
                    .is_err();
            }
        }
        false
    }
    #[cfg(not(unix))]
    {
        false
    }
}

/// Download and install the update - async version
pub async fn download_and_install(version: &str, yes: bool) -> Result<()> {
    let (arch, os) = get_platform()?;
    let install_dir = find_install_dir()?;

    println!("\x1b[36m🌳 Smart Tree Updater\x1b[0m");
    println!();
    println!("Current version: v{}", CURRENT_VERSION);
    println!("Latest version:  {}", version);
    println!("Install path:    {}", install_dir.display());
    println!("Binaries:        {}", BINARIES.join(", "));
    println!();

    if !yes {
        print!("Proceed with update? [Y/n] ");
        io::stdout().flush()?;

        let mut input = String::new();
        io::stdin().read_line(&mut input)?;
        let input = input.trim().to_lowercase();

        if !input.is_empty() && input != "y" && input != "yes" {
            println!("Update cancelled.");
            return Ok(());
        }
    }

    let use_sudo = needs_sudo(&install_dir);
    if use_sudo {
        println!("\x1b[33m⚠ Installation directory requires elevated permissions.\x1b[0m");
        println!("  You may be prompted for your password.\n");
    }

    // Construct download URL
    let ext = if cfg!(target_os = "windows") {
        "zip"
    } else {
        "tar.gz"
    };
    let archive_name = format!("st-{}-{}-{}.{}", version, arch, os, ext);
    let download_url = format!(
        "https://github.com/{}/releases/download/{}/{}",
        GITHUB_REPO, version, archive_name
    );

    println!("Downloading {}...", archive_name);

    // Create temp directory
    let temp_dir = create_temp_dir()?;
    let archive_path = temp_dir.join(&archive_name);

    // Download
    let client = reqwest::Client::builder()
        .user_agent("smart-tree-updater")
        .timeout(Duration::from_secs(300))
        .build()?;

    let response = client
        .get(&download_url)
        .send()
        .await
        .context("Failed to download release")?;

    if !response.status().is_success() {
        bail!("Download failed: HTTP {}", response.status());
    }

    let bytes = response.bytes().await?;
    fs::write(&archive_path, &bytes)?;

    println!("Extracting...");

    // Extract archive
    #[cfg(unix)]
    {
        let output = Command::new("tar")
            .args(["-xzf", archive_path.to_str().unwrap()])
            .current_dir(&temp_dir)
            .output()
            .context("Failed to extract archive")?;

        if !output.status.success() {
            bail!(
                "Failed to extract archive: {}",
                String::from_utf8_lossy(&output.stderr)
            );
        }
    }

    #[cfg(windows)]
    {
        // On Windows, use powershell to extract zip
        let output = Command::new("powershell")
            .args([
                "-Command",
                &format!(
                    "Expand-Archive -Path '{}' -DestinationPath '{}' -Force",
                    archive_path.display(),
                    &temp_dir.display()
                ),
            ])
            .output()
            .context("Failed to extract archive")?;

        if !output.status.success() {
            bail!(
                "Failed to extract archive: {}",
                String::from_utf8_lossy(&output.stderr)
            );
        }
    }

    // Install binaries
    println!("Installing binaries...");

    let mut installed_count = 0;
    for binary in BINARIES {
        let binary_name = if cfg!(windows) {
            format!("{}.exe", binary)
        } else {
            binary.to_string()
        };

        // Find binary in temp dir (might be at root or in subdirectory)
        let src_path = match find_binary_in_dir(&temp_dir, &binary_name) {
            Ok(path) => path,
            Err(_) => {
                // Binary not in archive - skip it (older releases may not have all binaries)
                println!("  \x1b[33m⚠\x1b[0m {} (not in archive, skipping)", binary);
                continue;
            }
        };
        let dest_path = install_dir.join(&binary_name);

        // IMPORTANT: Remove old binary first to avoid macOS zombie process issue
        #[cfg(unix)]
        {
            if use_sudo {
                let _ = Command::new("sudo")
                    .args(["rm", "-f", dest_path.to_str().unwrap()])
                    .status();

                Command::new("sudo")
                    .args([
                        "cp",
                        src_path.to_str().unwrap(),
                        dest_path.to_str().unwrap(),
                    ])
                    .status()
                    .context(format!("Failed to install {}", binary))?;

                Command::new("sudo")
                    .args(["chmod", "+x", dest_path.to_str().unwrap()])
                    .status()?;
            } else {
                let _ = fs::remove_file(&dest_path);
                fs::copy(&src_path, &dest_path).context(format!("Failed to install {}", binary))?;

                // Set executable permission
                use std::os::unix::fs::PermissionsExt;
                let mut perms = fs::metadata(&dest_path)?.permissions();
                perms.set_mode(0o755);
                fs::set_permissions(&dest_path, perms)?;
            }
        }

        #[cfg(windows)]
        {
            // On Windows, rename old binary first (can't delete while running)
            let old_path = install_dir.join(format!("{}.old", binary_name));
            let _ = fs::remove_file(&old_path);
            let _ = fs::rename(&dest_path, &old_path);

            fs::copy(&src_path, &dest_path).context(format!("Failed to install {}", binary))?;
        }

        println!("  \x1b[32m✓\x1b[0m {}", binary);
        installed_count += 1;
    }

    // Ensure at least the main binary was installed
    if installed_count == 0 {
        bail!("No binaries were installed from the archive");
    }

    // Update cache
    let mut cache = load_cache();
    cache.latest_version = Some(version.to_string());
    let _ = save_cache(&cache);

    // Clean up temp directory
    cleanup_temp_dir(&temp_dir);

    println!();
    println!("\x1b[32m✨ Successfully updated to {}!\x1b[0m", version);

    #[cfg(windows)]
    {
        println!();
        println!(
            "\x1b[33mNote: Please restart your terminal for the update to take effect.\x1b[0m"
        );
    }

    Ok(())
}

/// Find a binary file within a directory (handles nested extraction)
fn find_binary_in_dir(dir: &Path, binary_name: &str) -> Result<PathBuf> {
    // Check root
    let root_path = dir.join(binary_name);
    if root_path.exists() {
        return Ok(root_path);
    }

    // Search subdirectories
    for entry in fs::read_dir(dir)? {
        let entry = entry?;
        let path = entry.path();
        if path.is_dir() {
            let nested = path.join(binary_name);
            if nested.exists() {
                return Ok(nested);
            }
        }
    }

    bail!("Could not find {} in downloaded archive", binary_name)
}

/// Run the update command - async version
pub async fn run_update(yes: bool) -> Result<()> {
    println!("Checking for updates...");

    match check_for_update().await? {
        Some(version) => {
            download_and_install(&version, yes).await?;
        }
        None => {
            println!(
                "\x1b[32m✓\x1b[0m Already up to date! (v{})",
                CURRENT_VERSION
            );
        }
    }

    Ok(())
}

/// Get current version string
pub fn current_version() -> &'static str {
    CURRENT_VERSION
}

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

    #[test]
    fn test_version_comparison() {
        assert!(is_newer_version("5.5.0", "5.5.1"));
        assert!(is_newer_version("5.5.1", "5.6.0"));
        assert!(is_newer_version("5.5.1", "6.0.0"));
        assert!(is_newer_version("v5.5.0", "v5.5.1"));
        assert!(!is_newer_version("5.5.1", "5.5.1"));
        assert!(!is_newer_version("5.5.1", "5.5.0"));
        assert!(!is_newer_version("6.0.0", "5.5.1"));
    }

    #[test]
    fn test_platform_detection() {
        let result = get_platform();
        assert!(result.is_ok());
    }
}