mi6_cli/commands/

upgrade.rs

//! Self-upgrade command for mi6.
//!
//! Detects installation method and uses the appropriate upgrade strategy:
//! - Homebrew: `brew upgrade mi6`
//! - Cargo (registry): `cargo install mi6`
//! - Cargo (path): `cargo install --path <original-path>`
//! - Standalone: Uses `self_update` crate to download from GitHub releases
//!
//! Supports switching between installation methods with automatic rollback on failure.

use std::path::PathBuf;
use std::process::Command;

use anyhow::{Context, Result, bail};

use crate::args::UpgradeMethod;
use crate::display::{bold_green, bold_white, confirm_stdout};

use super::update_check::check_for_update_with_method;

/// How mi6 was installed
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum InstallMethod {
    /// Installed via Homebrew
    Homebrew,
    /// Installed via `cargo install mi6` (from crates.io registry)
    CargoRegistry,
    /// Installed via `cargo install --path <path>` (from local source)
    CargoPath(PathBuf),
    /// Standalone binary (e.g., downloaded from GitHub releases or install.sh)
    Standalone,
}

impl InstallMethod {
    /// Detect the installation method based on the executable path and cargo metadata
    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/") {
            return Ok(Self::Homebrew);
        }

        if path_str.contains("/.cargo/bin/") {
            // Use `cargo install --list` to determine if installed from registry or path
            if let Some(method) = Self::detect_cargo_source()? {
                return Ok(method);
            }
            // Fallback to registry if we can't determine
            return Ok(Self::CargoRegistry);
        }

        Ok(Self::Standalone)
    }

    /// Use `cargo install --list` to determine the install source
    ///
    /// Output format:
    /// - Registry install: `mi6 v0.2.0:`
    /// - Path install: `mi6 v0.2.0 (/path/to/crate):`
    fn detect_cargo_source() -> Result<Option<Self>> {
        let output = Command::new("cargo")
            .args(["install", "--list"])
            .output()
            .context("failed to run cargo install --list")?;

        if !output.status.success() {
            return Ok(None);
        }

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

        // Find the line starting with "mi6 v"
        for line in stdout.lines() {
            if !line.starts_with("mi6 v") {
                continue;
            }

            // Check if there's a path in parentheses: "mi6 v0.2.0 (/path/to/crate):"
            if let Some(start) = line.find(" (")
                && let Some(end) = line.rfind("):")
            {
                let path_str = &line[start + 2..end];
                return Ok(Some(Self::CargoPath(PathBuf::from(path_str))));
            }

            // No path means registry install: "mi6 v0.2.0:"
            return Ok(Some(Self::CargoRegistry));
        }

        Ok(None)
    }

    /// Get a human-readable name for the install method
    pub fn name(&self) -> &'static str {
        match self {
            Self::Homebrew => "Homebrew",
            Self::CargoRegistry => "Cargo (crates.io)",
            Self::CargoPath(_) => "Cargo source code",
            Self::Standalone => "Standalone binary",
        }
    }

    /// Convert to UpgradeMethod (for comparison purposes)
    pub fn to_upgrade_method(&self) -> UpgradeMethod {
        match self {
            Self::Homebrew => UpgradeMethod::Brew,
            Self::CargoRegistry => UpgradeMethod::CargoCrates,
            Self::CargoPath(_) => UpgradeMethod::CargoSource,
            Self::Standalone => UpgradeMethod::Github,
        }
    }

    /// Create from UpgradeMethod with optional path for CargoSource
    pub fn from_upgrade_method(method: UpgradeMethod, path: Option<PathBuf>) -> Result<Self> {
        match method {
            UpgradeMethod::Brew => Ok(Self::Homebrew),
            UpgradeMethod::CargoCrates => Ok(Self::CargoRegistry),
            UpgradeMethod::Github => Ok(Self::Standalone),
            UpgradeMethod::CargoSource => {
                let source_path = path.ok_or_else(|| {
                    anyhow::anyhow!(
                        "--source-path is required when using --method cargo_source\n\
                         Example: mi6 upgrade --method cargo_source --source-path /path/to/mi6"
                    )
                })?;
                Ok(Self::CargoPath(source_path))
            }
        }
    }

    /// Check if prerequisites for this installation method are met
    pub fn check_prerequisites(&self) -> Result<()> {
        match self {
            Self::Homebrew => {
                let output = Command::new("brew")
                    .arg("--version")
                    .output()
                    .context("brew is not installed or not in PATH")?;
                if !output.status.success() {
                    bail!("brew is not working properly");
                }
                Ok(())
            }
            Self::CargoRegistry | Self::CargoPath(_) => {
                let output = Command::new("cargo")
                    .arg("--version")
                    .output()
                    .context("cargo is not installed or not in PATH")?;
                if !output.status.success() {
                    bail!("cargo is not working properly");
                }
                // For CargoPath, check that the source directory exists and is a valid Rust project
                if let Self::CargoPath(path) = self {
                    if !path.exists() {
                        bail!(
                            "Source directory does not exist: {}\n\
                             Please provide a valid path to the mi6 source.",
                            path.display()
                        );
                    }
                    let cargo_toml = path.join("Cargo.toml");
                    if !cargo_toml.exists() {
                        bail!(
                            "Not a valid Rust project (no Cargo.toml): {}\n\
                             Please provide a path to the mi6 source directory.",
                            path.display()
                        );
                    }
                }
                Ok(())
            }
            Self::Standalone => {
                // No prerequisites for standalone - just needs network access
                Ok(())
            }
        }
    }
}

/// Options for the upgrade command
pub struct UpgradeOptions {
    /// Target version (only for Cargo registry installs)
    pub version: Option<String>,
    /// Skip confirmation prompt
    pub yes: bool,
    /// Check for updates without installing
    pub dry_run: bool,
    /// Override installation method
    pub method: Option<UpgradeMethod>,
    /// Source path for cargo_source method
    pub source_path: Option<PathBuf>,
}

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

    println!("mi6 v{}", current_version);
    println!();
    println!(
        "{} {}",
        bold_green("Installation method:"),
        current_method.name()
    );
    if let InstallMethod::CargoPath(path) = &current_method {
        println!("{} {}", bold_green("   Source code path:"), path.display());
    }
    println!();

    // Determine target method (either specified or current)
    let target_method = if let Some(method) = options.method {
        // If switching to cargo_source and no path provided, try to use current path
        let path = options.source_path.clone().or_else(|| {
            if let InstallMethod::CargoPath(p) = &current_method {
                Some(p.clone())
            } else {
                None
            }
        });
        // Canonicalize the path to avoid issues with relative paths
        let path = path.map(|p| p.canonicalize().unwrap_or(p));
        InstallMethod::from_upgrade_method(method, path)?
    } else {
        current_method.clone()
    };

    let is_switching = current_method.to_upgrade_method() != target_method.to_upgrade_method();

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

    // Handle dry-run mode
    if options.dry_run {
        if is_switching {
            println!(
                "Would switch from {} to {}",
                current_method.name(),
                target_method.name()
            );
            println!();

            // Check prerequisites even in dry-run to warn early
            print!("Checking prerequisites for {}... ", target_method.name());
            match target_method.check_prerequisites() {
                Ok(()) => println!("OK"),
                Err(e) => {
                    println!("FAILED");
                    println!();
                    println!("Warning: Switch would fail: {}", e);
                    println!();
                }
            }
        }
        return check_for_updates(current_version, &target_method);
    }

    // If switching methods, go through the switch flow
    if is_switching {
        return switch_method(&current_method, &target_method, &options);
    }

    // Check if already on latest version (skip if user specified a specific version)
    // Also skip for standalone installs - upgrade_standalone() does its own check,
    // so doing it here would result in duplicate GitHub API calls
    if options.version.is_none() && !matches!(target_method, InstallMethod::Standalone) {
        println!("Checking for updates...");
        match check_for_update_with_method(current_version, &target_method) {
            Ok(None) => {
                // For git source installs, show commit hash even when on latest
                if matches!(target_method, InstallMethod::CargoPath(_)) {
                    if let Some(current_hash) =
                        option_env!("MI6_GIT_COMMIT").filter(|s| !s.is_empty())
                    {
                        println!(
                            "{} {} ({})",
                            bold_green("  Installed version:"),
                            bold_white(current_hash),
                            bold_white(&format!("v{}", current_version))
                        );
                        println!(
                            "{} {} ({})",
                            bold_green("     Latest version:"),
                            bold_white(current_hash),
                            bold_white(&format!("v{}", current_version))
                        );
                        println!();
                        println!(
                            "Already on latest version {} ({})",
                            bold_white(current_hash),
                            bold_white(&format!("v{}", current_version))
                        );
                    } else {
                        println!(
                            "Already on latest version ({}).",
                            bold_white(&format!("v{}", current_version))
                        );
                    }
                } else {
                    println!(
                        "Already on latest version ({}).",
                        bold_white(&format!("v{}", current_version))
                    );
                }
                return Ok(());
            }
            Ok(Some(update_info)) => {
                // For git source installs, show commit hashes
                if let Some(ref current_hash) = update_info.current_git_hash {
                    let latest_hash = update_info
                        .latest_version
                        .strip_prefix("git:")
                        .unwrap_or(&update_info.latest_version);
                    println!(
                        "{} {} ({})",
                        bold_green("  Installed version:"),
                        bold_white(current_hash),
                        bold_white(&format!("v{}", current_version))
                    );
                    println!(
                        "{} {} ({})",
                        bold_green("     Latest version:"),
                        bold_white(latest_hash),
                        bold_white(&format!("v{}", current_version))
                    );
                } else {
                    println!(
                        "{} {}",
                        bold_green("  Installed version:"),
                        bold_white(&format!("v{}", current_version))
                    );
                    println!(
                        "{} {}",
                        bold_green("     Latest version:"),
                        bold_white(&format!("v{}", update_info.latest_version))
                    );
                }
                println!();
            }
            Err(e) => {
                // Log warning but continue with upgrade anyway
                println!("Check failed: {}", e);
                println!();
                println!("Continuing with upgrade...");
                println!();
            }
        }
    }

    // Same method upgrade
    let completed = match &target_method {
        InstallMethod::Homebrew => upgrade_homebrew(options.yes)?,
        InstallMethod::CargoRegistry => {
            upgrade_cargo_registry(options.version.as_deref(), options.yes)?
        }
        InstallMethod::CargoPath(path) => upgrade_cargo_path(path, options.yes)?,
        InstallMethod::Standalone => upgrade_standalone(current_version, options.yes)?,
    };

    if completed {
        println!();
        println!("Done! Run `mi6 --version` to verify.");
    }

    Ok(())
}

/// Switch from one installation method to another.
///
/// This function ensures the mi6 binary is always available during the switch
/// by installing the new method BEFORE uninstalling the old one. This is critical
/// for live sessions that have hooks calling `mi6 ingest event`.
///
/// For cargo-to-cargo switches (same binary location), the install atomically
/// overwrites so no separate uninstall is needed.
fn switch_method(from: &InstallMethod, to: &InstallMethod, options: &UpgradeOptions) -> Result<()> {
    println!(
        "Switching installation method: {} -> {}",
        from.name(),
        to.name()
    );
    println!();

    // Step 1: Check prerequisites for the new method BEFORE any changes
    println!("Checking prerequisites for {}...", to.name());
    to.check_prerequisites()
        .with_context(|| format!("Cannot switch to {}: prerequisites not met", to.name()))?;
    println!("Prerequisites OK.");
    println!();

    // Determine if this is a cargo-to-cargo switch (same binary location, atomic overwrite)
    let is_cargo_to_cargo = matches!(
        (from, to),
        (
            InstallMethod::CargoRegistry | InstallMethod::CargoPath(_),
            InstallMethod::CargoRegistry | InstallMethod::CargoPath(_)
        )
    );

    // Step 2: Confirm with user
    if !options.yes {
        println!("This will:");
        if is_cargo_to_cargo {
            println!("  Install mi6 via {} (overwrites existing)", to.name());
        } else {
            println!("  1. Install mi6 via {}", to.name());
            println!("  2. Uninstall mi6 via {} (binary only)", from.name());
        }
        println!();
        println!("Note: Your mi6 data (database, config, themes) will be preserved.");
        println!();
        if !confirm_stdout("Proceed with method switch?")? {
            println!("Aborted.");
            return Ok(());
        }
        println!();
    }

    if is_cargo_to_cargo {
        // Cargo-to-cargo: atomic overwrite, use --force to ensure replacement
        println!("Installing via {} (atomic overwrite)...", to.name());
        install_binary_forced(to, options.version.as_deref())
            .with_context(|| format!("Failed to install via {}", to.name()))?;
    } else {
        // Different locations: install new first, then uninstall old
        // This ensures mi6 is always available for live sessions

        // Step 3: Install new method first (old binary still available)
        println!("Installing via {}...", to.name());
        if let Err(install_err) = install_binary(to, options.version.as_deref()) {
            // Install failed, but old binary is still there - no rollback needed
            bail!(
                "Failed to install via {}: {}\n\n\
                 Your current installation ({}) is unchanged.",
                to.name(),
                install_err,
                from.name()
            );
        }
        println!("Install complete.");
        println!();

        // Step 4: Now safe to uninstall old method (new binary is ready)
        println!("Removing old installation ({})...", from.name());
        if let Err(uninstall_err) = uninstall_binary(from) {
            // New binary is installed, but old one couldn't be removed
            // This is not critical - warn user but don't fail
            eprintln!();
            eprintln!(
                "WARNING: Could not remove old {} installation: {}",
                from.name(),
                uninstall_err
            );
            eprintln!();
            eprintln!("You may have two mi6 binaries installed.");
            eprintln!("Run `which mi6` to verify you're using the correct binary.");
            eprintln!();
        } else {
            println!("Old installation removed.");
            println!();
        }
    }

    println!(
        "Done! Successfully switched from {} to {}.",
        from.name(),
        to.name()
    );
    println!("Run `mi6 --version` to verify.");

    Ok(())
}

/// Uninstall the mi6 binary using the specified method (binary only, preserves data).
fn uninstall_binary(method: &InstallMethod) -> Result<()> {
    match method {
        InstallMethod::Homebrew => {
            let status = Command::new("brew")
                .args(["uninstall", "mi6"])
                .status()
                .context("failed to run brew uninstall")?;
            if !status.success() {
                bail!("brew uninstall failed with exit code: {:?}", status.code());
            }
        }
        InstallMethod::CargoRegistry | InstallMethod::CargoPath(_) => {
            let status = Command::new("cargo")
                .args(["uninstall", "mi6"])
                .status()
                .context("failed to run cargo uninstall")?;
            if !status.success() {
                bail!("cargo uninstall failed with exit code: {:?}", status.code());
            }
        }
        InstallMethod::Standalone => {
            let exe_path =
                std::env::current_exe().context("failed to get current executable path")?;
            std::fs::remove_file(&exe_path)
                .with_context(|| format!("failed to delete {}", exe_path.display()))?;
        }
    }
    Ok(())
}

/// Install the mi6 binary using the specified method.
fn install_binary(method: &InstallMethod, version: Option<&str>) -> Result<()> {
    install_binary_impl(method, version, false)
}

/// Install the mi6 binary with --force flag (for cargo-to-cargo switches).
fn install_binary_forced(method: &InstallMethod, version: Option<&str>) -> Result<()> {
    install_binary_impl(method, version, true)
}

/// Internal implementation of binary installation.
fn install_binary_impl(method: &InstallMethod, version: Option<&str>, force: bool) -> Result<()> {
    match method {
        InstallMethod::Homebrew => {
            let status = Command::new("brew")
                .args(["install", "mi6"])
                .status()
                .context("failed to run brew install")?;
            if !status.success() {
                bail!("brew install failed with exit code: {:?}", status.code());
            }
        }
        InstallMethod::CargoRegistry => {
            let mut args = vec!["install", "mi6"];
            if force {
                args.push("--force");
            }
            if let Some(v) = version {
                args.extend(["--version", v]);
            }
            let status = Command::new("cargo")
                .args(&args)
                .status()
                .context("failed to run cargo install")?;
            if !status.success() {
                bail!("cargo install failed with exit code: {:?}", status.code());
            }
        }
        InstallMethod::CargoPath(path) => {
            let path_str = path.to_string_lossy();
            let mut args = vec!["install", "--path", path_str.as_ref()];
            if force {
                args.push("--force");
            }
            let status = Command::new("cargo")
                .args(&args)
                .status()
                .context("failed to run cargo install --path")?;
            if !status.success() {
                bail!(
                    "cargo install --path failed with exit code: {:?}",
                    status.code()
                );
            }
        }
        InstallMethod::Standalone => {
            // When switching TO standalone, we must install to a DIFFERENT location
            // than the current binary. By default, self_update replaces current_exe(),
            // which would be the brew/cargo location - then uninstall would delete it!
            //
            // Install to /usr/local/bin (standard location for standalone binaries)
            let install_dir = PathBuf::from("/usr/local/bin");

            // Ensure the directory exists and is writable
            if !install_dir.exists() {
                std::fs::create_dir_all(&install_dir).with_context(|| {
                    format!(
                        "Cannot create install directory: {}\n\
                         You may need to run with sudo or choose a different installation method.",
                        install_dir.display()
                    )
                })?;
            }

            // Use self_update to download from GitHub releases
            // Use "0.0.0" as current version to force download even if versions match.
            let status = self_update::backends::github::Update::configure()
                .repo_owner("paradigmxyz")
                .repo_name("mi6")
                .bin_name("mi6")
                .bin_install_path(&install_dir)
                .current_version("0.0.0") // Force download
                .show_download_progress(true)
                .build()
                .context("failed to configure self-updater")?
                .update()
                .context("failed to download from GitHub releases")?;

            // Verify the download actually happened
            if !status.updated() {
                bail!(
                    "GitHub download did not produce a binary. \
                     This may indicate a problem with the release assets."
                );
            }

            // Remind user about PATH if /usr/local/bin might not be in it
            let installed_path = install_dir.join("mi6");
            println!();
            println!("Installed to: {}", installed_path.display());
            println!("Ensure /usr/local/bin is in your PATH.");
        }
    }
    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::CargoRegistry => {
            println!("To check for Cargo updates, run:");
            println!("  cargo search mi6");
        }
        InstallMethod::CargoPath(path) => {
            println!("Installed from source at: {}", path.display());
            println!();
            println!("To check for updates, pull latest changes and reinstall:");
            println!("  mi6 upgrade");
        }
    }

    Ok(())
}

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

fn upgrade_cargo_registry(version: Option<&str>, skip_confirm: bool) -> Result<bool> {
    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(false);
        }
        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(true)
}

fn upgrade_cargo_path(path: &std::path::Path, skip_confirm: bool) -> Result<bool> {
    // Verify the path still exists
    if !path.exists() {
        anyhow::bail!(
            "Source directory no longer exists: {}\n\
             You may need to reinstall mi6 or update the source location.",
            path.display()
        );
    }

    // Find the workspace root (look for Cargo.toml with [workspace])
    let workspace_root = find_workspace_root(path)?;

    // Determine the git pull target - if we're in a worktree, pull from main worktree instead
    let pull_target = workspace_root.as_ref().and_then(|root| {
        let git_dir = root.join(".git");
        if git_dir.exists() {
            Some(find_main_worktree(root).unwrap_or_else(|| root.clone()))
        } else {
            None
        }
    });

    let path_str = path.to_string_lossy();
    let args = vec!["install", "--path", path_str.as_ref()];

    if !skip_confirm {
        println!("{}", bold_green("Upgrade process:"));
        if let Some(ref target) = pull_target {
            println!(
                "{} Pull latest changes ({})",
                bold_green("1."),
                bold_white(&format!("git pull -C {}", target.display()))
            );
            println!(
                "{} Run cargo install ({})",
                bold_green("2."),
                bold_white(&format!("cargo {}", args.join(" ")))
            );
        } else {
            println!(
                "Run cargo install ({})",
                bold_white(&format!("cargo {}", args.join(" ")))
            );
        }
        println!();
        if !confirm_stdout("Proceed?")? {
            println!("Aborted.");
            return Ok(false);
        }
        println!();
    }

    // Pull latest changes if we have a git directory
    if let Some(ref target) = pull_target {
        println!("Pulling latest changes...");
        let target_str = target.to_string_lossy();

        let status = Command::new("git")
            .args(["-C", target_str.as_ref(), "pull"])
            .status()
            .context("failed to run git pull")?;

        if !status.success() {
            anyhow::bail!("git pull failed. Please resolve any conflicts or issues and try again.");
        }
        println!();
    }

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

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

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

    Ok(true)
}

/// Find the workspace root by looking for Cargo.toml with [workspace] section
fn find_workspace_root(crate_path: &std::path::Path) -> Result<Option<PathBuf>> {
    let mut current = crate_path.to_path_buf();

    // Walk up the directory tree looking for workspace Cargo.toml
    for _ in 0..10 {
        let cargo_toml = current.join("Cargo.toml");
        if cargo_toml.exists() {
            let content = std::fs::read_to_string(&cargo_toml)?;
            if content.contains("[workspace]") {
                return Ok(Some(current));
            }
        }

        if !current.pop() {
            break;
        }
    }

    Ok(None)
}

/// Find the main worktree directory from any git directory (including worktrees).
///
/// If the given path is within a git worktree, this returns the main worktree
/// (the original repo directory). If it's already in the main worktree, returns None.
fn find_main_worktree(git_path: &std::path::Path) -> Option<PathBuf> {
    let path_str = git_path.to_string_lossy();

    // Get the common git directory (shared across all worktrees)
    let output = Command::new("git")
        .args([
            "-C",
            &path_str,
            "rev-parse",
            "--path-format=absolute",
            "--git-common-dir",
        ])
        .output()
        .ok()?;

    if !output.status.success() {
        return None;
    }

    let common_dir = String::from_utf8_lossy(&output.stdout).trim().to_string();
    let common_path = PathBuf::from(&common_dir);

    // The main worktree is the parent of the common .git directory
    // (e.g., /path/to/repo/.git -> /path/to/repo)
    let main_worktree = common_path.parent()?.to_path_buf();

    // Check if we're already in the main worktree by comparing to current path
    // Get the git dir for the given path
    let git_dir_output = Command::new("git")
        .args([
            "-C",
            &path_str,
            "rev-parse",
            "--path-format=absolute",
            "--git-dir",
        ])
        .output()
        .ok()?;

    if !git_dir_output.status.success() {
        return None;
    }

    let git_dir = String::from_utf8_lossy(&git_dir_output.stdout)
        .trim()
        .to_string();

    // If git-dir equals git-common-dir, we're in the main worktree
    if git_dir == common_dir {
        return None;
    }

    Some(main_worktree)
}

fn upgrade_standalone(current_version: &str, skip_confirm: bool) -> Result<bool> {
    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(true);
    }

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

    if !skip_confirm && !confirm_stdout("Proceed with update?")? {
        println!("Aborted.");
        return Ok(false);
    }
    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(true)
}