mi6_cli/commands/

uninstall.rs

//! Uninstall command - completely remove mi6 from the system.
//!
//! This command:
//! 1. Disables mi6 hooks for all enabled frameworks
//! 2. Optionally deletes the mi6 data directory (MI6_DIR_PATH or ~/.mi6)
//! 3. Uninstalls the mi6 binary based on detected installation method

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

use anyhow::{Context, Result};

use mi6_core::{
    Config, FrameworkAdapter, FrameworkResolutionMode, all_adapters, resolve_frameworks,
};

use super::disable::disable_framework_silent;
use super::upgrade::InstallMethod;
use crate::display::{StderrColors, confirm};

/// Options for the uninstall command
pub struct UninstallOptions {
    /// Skip confirmation prompts
    pub confirm: 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 colors = StderrColors::new();
    let method = InstallMethod::detect()?;

    eprintln!("{}mi6 uninstall{}", colors.bold, colors.reset);
    eprintln!("Detected installation method: {}", method.name());
    eprintln!();

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

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

    // Step 2: Show data that will be deleted
    if !options.keep_data && data_exists {
        eprintln!("{}Step 2:{} Delete mi6 data", colors.cyan, colors.reset);
        if let Some(ref dir) = mi6_dir
            && dir.exists()
        {
            eprintln!("  - {} (database, config, themes)", dir.display());
        }
        eprintln!();
    } else if options.keep_data {
        eprintln!(
            "{}Step 2:{} Keeping mi6 data (--keep-data)",
            colors.cyan, colors.reset
        );
        eprintln!();
    } else {
        eprintln!(
            "{}Step 2:{} No mi6 data to delete",
            colors.cyan, colors.reset
        );
        eprintln!();
    }

    // Step 3: Show uninstall command
    eprintln!(
        "{}Step 3:{} Uninstall mi6 binary",
        colors.cyan, colors.reset
    );
    match method {
        InstallMethod::Homebrew => eprintln!("  brew uninstall mi6"),
        InstallMethod::Cargo => eprintln!("  cargo uninstall mi6"),
        InstallMethod::Standalone => {
            if let Ok(exe_path) = std::env::current_exe() {
                eprintln!("  rm {}", exe_path.display());
            } else {
                eprintln!("  (remove mi6 binary manually)");
            }
        }
    }
    eprintln!();

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

    // Confirm with user (ask about data deletion before any operations)
    if !options.confirm {
        eprintln!(
            "{}This will permanently uninstall mi6.{}",
            colors.yellow, colors.reset
        );

        // If there's data and we're not keeping it, emphasize this
        if !options.keep_data && data_exists {
            eprintln!(
                "{}All mi6 data (sessions, events, config) will be deleted.{}",
                colors.yellow, colors.reset
            );
        }

        if !confirm("Proceed with uninstall?")? {
            eprintln!("Aborted.");
            return Ok(());
        }
        eprintln!();
    }

    // Execute Step 1: Disable frameworks
    if !enabled_frameworks.is_empty() {
        eprint!("{}Disabling{} mi6 hooks... ", colors.green, colors.reset);
        for adapter in &enabled_frameworks {
            disable_framework_silent(*adapter)?;
        }
        eprintln!("{}done{}", colors.green, colors.reset);
    }

    // Execute Step 2: Delete data
    if !options.keep_data
        && let Some(ref dir) = mi6_dir
        && dir.exists()
    {
        eprint!(
            "{}Deleting{} {}... ",
            colors.green,
            colors.reset,
            dir.display()
        );
        std::fs::remove_dir_all(dir)
            .with_context(|| format!("failed to delete {}", dir.display()))?;
        eprintln!("{}done{}", colors.green, colors.reset);
    }

    // Execute Step 3: Uninstall binary
    eprint!(
        "{}Uninstalling{} mi6 binary... ",
        colors.green, colors.reset
    );
    match method {
        InstallMethod::Homebrew => uninstall_homebrew()?,
        InstallMethod::Cargo => uninstall_cargo()?,
        InstallMethod::Standalone => uninstall_standalone()?,
    }
    eprintln!("{}done{}", colors.green, colors.reset);

    eprintln!();
    eprintln!("{}mi6 has been uninstalled.{}", colors.bold, colors.reset);

    Ok(())
}

/// Find all frameworks that have mi6 enabled
fn find_enabled_frameworks() -> Vec<&'static dyn FrameworkAdapter> {
    // Check global config for all frameworks
    let mode = FrameworkResolutionMode::Active {
        local: false,
        settings_local: false,
    };

    // Try to resolve with empty list (will find all enabled)
    match resolve_frameworks(&[], Some(mode)) {
        Ok(adapters) => adapters,
        Err(_) => {
            // Fallback: check each adapter individually
            all_adapters()
                .into_iter()
                .filter(|a| a.has_mi6_hooks(false, false))
                .collect()
        }
    }
}

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

/// 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(())
}