mi6_cli/commands/

uninstall.rs

//! Uninstall command - completely remove mi6 from the system.
//!
//! This command performs a complete uninstallation in the following order:
//! 1. Disables mi6 hooks for all enabled frameworks (all scopes)
//! 2. Stops the OTel server if running
//! 3. Uninstalls the mi6 binary based on detected installation method
//! 4. Optionally deletes the mi6 data directory (prompts user unless --yes or --keep-data)
//!
//! The order is designed so that if any step fails, the user hasn't lost their data yet.

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

use anyhow::{Context, Result};

use mi6_core::{Config, FrameworkAdapter, all_adapters};
use mi6_otel_server::lifecycle::{DEFAULT_PORT, is_mi6_server, stop_server};

use super::upgrade::InstallMethod;
use crate::display::{bold_green, bold_white, bold_yellow, confirm};

/// Options for the uninstall command
pub struct UninstallOptions {
    /// Skip all confirmation prompts (auto-delete data)
    pub yes: bool,
    /// Keep mi6 data (database, config, themes)
    pub keep_data: bool,
    /// Show what would happen without actually doing it
    pub dry_run: bool,
}

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

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

    // Gather information about what will be done
    let enabled_frameworks = find_all_enabled_frameworks();
    let mi6_dir = get_mi6_dir();
    let data_exists = mi6_dir.as_ref().is_some_and(|p| p.exists());
    let otel_running = is_mi6_server(DEFAULT_PORT);

    println!("{}", bold_green("Uninstall steps:"));

    // Step 1: Show frameworks that will be disabled
    if enabled_frameworks.is_empty() {
        println!("{} No enabled frameworks found", bold_green("1."));
    } else {
        println!("{} Disable mi6 hooks", bold_green("1."));
        for (adapter, scope) in &enabled_frameworks {
            println!("   - {} ({})", bold_white(adapter.display_name()), scope);
        }
    }

    // Step 2: Show OTel server status
    if otel_running {
        println!(
            "{} Stop OTel server ({})",
            bold_green("2."),
            bold_white(&format!("port {}", DEFAULT_PORT))
        );
    } else {
        println!("{} OTel server not running", bold_green("2."));
    }

    // Step 3: Show uninstall command
    println!(
        "{} Uninstall mi6 binary ({})",
        bold_green("3."),
        bold_white(get_uninstall_command(&method).as_str())
    );

    // Step 4: Show data deletion status
    if options.keep_data {
        println!("{} Keeping mi6 data (--keep-data)", bold_green("4."));
    } else if data_exists {
        if let Some(ref dir) = mi6_dir {
            println!("{} Delete mi6 data (will prompt)", bold_green("4."));
            println!(
                "   - {} (database, config, themes)",
                bold_white(&dir.display().to_string())
            );
        }
    } else {
        println!("{} No mi6 data to delete", bold_green("4."));
    }
    println!();

    // If dry run, stop here
    if options.dry_run {
        println!("{} No changes made.", bold_yellow("Dry run:"));
        return Ok(());
    }

    // Confirm with user before proceeding
    if !options.yes {
        if !confirm("Uninstall mi6?")? {
            eprintln!("Aborted.");
            return Ok(());
        }
        println!();
    }

    // Execute Step 1: Disable frameworks (all scopes)
    if !enabled_frameworks.is_empty() {
        print!("{} mi6 hooks... ", bold_green("Disabling"));
        std::io::stdout().flush().ok();
        for (adapter, _scope) in &enabled_frameworks {
            // Disable in all scope combinations - ignore errors for scopes that don't have hooks
            let _ = adapter.uninstall_hooks(false, false); // global
            let _ = adapter.uninstall_hooks(true, false); // local
            let _ = adapter.uninstall_hooks(false, true); // settings_local
        }
        // Remove Claude marketplace registration
        remove_claude_marketplace();
        println!("{}", bold_green("done"));
    }

    // Execute Step 2: Stop OTel server
    if otel_running {
        print!("{} OTel server... ", bold_green("Stopping"));
        std::io::stdout().flush().ok();
        // Ignore errors - best effort cleanup
        let _ = stop_server(DEFAULT_PORT);
        println!("{}", bold_green("done"));
    }

    // Execute Step 3: Uninstall binary
    print!("{} mi6 binary... ", bold_green("Uninstalling"));
    std::io::stdout().flush().ok();
    match &method {
        InstallMethod::Homebrew => uninstall_homebrew()?,
        InstallMethod::CargoRegistry | InstallMethod::CargoPath(_) => uninstall_cargo()?,
        InstallMethod::Standalone => uninstall_standalone()?,
    }
    println!("{}", bold_green("done"));

    // Execute Step 4: Delete data (prompt user unless --yes or --keep-data)
    if !options.keep_data
        && let Some(ref dir) = mi6_dir
        && dir.exists()
    {
        let should_delete = if options.yes {
            true
        } else {
            println!();
            eprintln!("{} {}", bold_yellow("mi6 data directory:"), dir.display());
            confirm("Delete mi6 data (database, config, themes)?")?
        };

        if should_delete {
            print!("{} {}... ", bold_green("Deleting"), dir.display());
            std::io::stdout().flush().ok();
            std::fs::remove_dir_all(dir)
                .with_context(|| format!("failed to delete {}", dir.display()))?;
            println!("{}", bold_green("done"));
        } else {
            eprintln!("Keeping mi6 data.");
        }
    }

    println!();
    println!("Done! mi6 has been uninstalled.");

    Ok(())
}

/// Get the uninstall command string for display
fn get_uninstall_command(method: &InstallMethod) -> String {
    match method {
        InstallMethod::Homebrew => "brew uninstall mi6".to_string(),
        InstallMethod::CargoRegistry | InstallMethod::CargoPath(_) => {
            "cargo uninstall mi6".to_string()
        }
        InstallMethod::Standalone => {
            if let Ok(exe_path) = std::env::current_exe() {
                format!("rm {}", exe_path.display())
            } else {
                "(remove mi6 binary manually)".to_string()
            }
        }
    }
}

/// Scope description for display
fn scope_name(local: bool, settings_local: bool) -> &'static str {
    if settings_local {
        "settings-local"
    } else if local {
        "local"
    } else {
        "global"
    }
}

/// Find all frameworks that have mi6 enabled in any scope.
///
/// Returns a list of (adapter, scope_description) tuples.
fn find_all_enabled_frameworks() -> Vec<(&'static dyn FrameworkAdapter, &'static str)> {
    let mut results = Vec::new();

    for adapter in all_adapters() {
        // Check all scope combinations
        for (local, settings_local) in [(false, false), (true, false), (false, true)] {
            if adapter.has_mi6_hooks(local, settings_local) {
                results.push((adapter, scope_name(local, settings_local)));
            }
        }
    }

    results
}

/// Get the main mi6 data directory (MI6_DIR_PATH or ~/.mi6)
fn get_mi6_dir() -> Option<PathBuf> {
    Config::mi6_dir().ok()
}

/// Remove the Claude marketplace registration.
///
/// This is a best-effort cleanup - errors are silently ignored.
fn remove_claude_marketplace() {
    // Get the marketplace path
    let Some(home) = dirs::home_dir() else {
        return;
    };
    let cache_path = home.join(".mi6/claude-plugin");

    // Only try to remove if it exists
    if !cache_path.exists() {
        return;
    }

    let cache_path_str = cache_path.to_string_lossy();

    // Run: claude plugin marketplace remove <path>
    // Ignore errors - the marketplace might not exist or claude might not be installed
    let _ = Command::new("claude")
        .args(["plugin", "marketplace", "remove", &cache_path_str])
        .output();
}

/// Uninstall via Homebrew
fn uninstall_homebrew() -> Result<()> {
    let status = Command::new("brew")
        .args(["uninstall", "mi6"])
        .status()
        .context("failed to run brew uninstall")?;

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

    Ok(())
}

/// Uninstall via Cargo
fn uninstall_cargo() -> Result<()> {
    let status = Command::new("cargo")
        .args(["uninstall", "mi6"])
        .status()
        .context("failed to run cargo uninstall")?;

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

    Ok(())
}

/// Uninstall standalone binary
fn uninstall_standalone() -> Result<()> {
    let exe_path = std::env::current_exe().context("failed to get current executable path")?;

    // On Unix, we can delete ourselves while running
    // On Windows, this would fail, but mi6 is primarily for Unix systems
    std::fs::remove_file(&exe_path)
        .with_context(|| format!("failed to delete {}", exe_path.display()))?;

    Ok(())
}