diskforge_core/

cleaner.rs

use std::fs::{self, OpenOptions};
use std::io::{ErrorKind, Write};
use std::path::Path;

use thiserror::Error;

use crate::sizing::format_size;

#[derive(Debug, Error)]
pub enum CleanError {
    #[error("path does not exist: {0}")]
    NotFound(String),
    #[error("permission denied: {0}")]
    PermissionDenied(String),
    #[error("io error removing {path}: {source}")]
    Io {
        path: String,
        source: std::io::Error,
    },
}

/// Result of a single deletion
#[derive(Debug)]
pub struct CleanedItem {
    pub path: String,
    pub size: u64,
    pub success: bool,
    pub error: Option<String>,
}

/// Run a shell command to clean (used for Docker, etc.)
pub fn run_cleanup_command(command: &str, size: u64) -> CleanedItem {
    let result = std::process::Command::new("sh")
        .args(["-c", command])
        .output();
    let item = match result {
        Ok(output) if output.status.success() => CleanedItem {
            path: command.to_string(),
            size,
            success: true,
            error: None,
        },
        Ok(output) => CleanedItem {
            path: command.to_string(),
            size: 0,
            success: false,
            error: Some(String::from_utf8_lossy(&output.stderr).trim().to_string()),
        },
        Err(e) => CleanedItem {
            path: command.to_string(),
            size: 0,
            success: false,
            error: Some(e.to_string()),
        },
    };
    log_operation(&item);
    item
}

/// Delete a single file. On permission denied, retries with elevated privileges via macOS auth dialog.
pub fn remove_file(path: &Path, size: u64) -> CleanedItem {
    let path_str = path.to_string_lossy().to_string();

    if !path.exists() {
        return CleanedItem {
            path: path_str,
            size: 0,
            success: false,
            error: Some("path does not exist".into()),
        };
    }

    let item = match fs::remove_file(path) {
        Ok(()) => CleanedItem {
            path: path_str,
            size,
            success: true,
            error: None,
        },
        Err(e) if e.kind() == ErrorKind::PermissionDenied => elevated_remove(&path_str, size),
        Err(e) => CleanedItem {
            path: path_str,
            size: 0,
            success: false,
            error: Some(e.to_string()),
        },
    };
    log_operation(&item);
    item
}

/// Delete a path — dispatches to `remove_file` or `remove_dir` based on path type
pub fn remove_path(path: &Path, size: u64) -> CleanedItem {
    if path.is_file() {
        remove_file(path, size)
    } else {
        remove_dir(path, size)
    }
}

/// Delete a directory and all its contents. On permission denied, retries with elevated privileges.
pub fn remove_dir(path: &Path, size: u64) -> CleanedItem {
    let path_str = path.to_string_lossy().to_string();

    if !path.exists() {
        return CleanedItem {
            path: path_str,
            size: 0,
            success: false,
            error: Some("path does not exist".into()),
        };
    }

    let item = match fs::remove_dir_all(path) {
        Ok(()) => CleanedItem {
            path: path_str,
            size,
            success: true,
            error: None,
        },
        Err(e) if e.kind() == ErrorKind::PermissionDenied => elevated_remove(&path_str, size),
        Err(e) => CleanedItem {
            path: path_str,
            size: 0,
            success: false,
            error: Some(e.to_string()),
        },
    };
    log_operation(&item);
    item
}

/// Retry deletion with elevated privileges using macOS native auth dialog.
/// Shows the system password prompt via `osascript`.
fn elevated_remove(path: &str, size: u64) -> CleanedItem {
    // Escape single quotes in the path for shell safety
    let escaped = path.replace('\'', "'\\''");
    let script = format!("do shell script \"rm -rf '{escaped}'\" with administrator privileges");

    let result = std::process::Command::new("osascript")
        .args(["-e", &script])
        .output();

    match result {
        Ok(output) if output.status.success() => CleanedItem {
            path: path.to_string(),
            size,
            success: true,
            error: None,
        },
        Ok(output) => {
            let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
            let error = if stderr.contains("User canceled") || stderr.contains("-128") {
                "permission denied (auth cancelled)".to_string()
            } else {
                format!("elevated removal failed: {stderr}")
            };
            CleanedItem {
                path: path.to_string(),
                size: 0,
                success: false,
                error: Some(error),
            }
        }
        Err(e) => CleanedItem {
            path: path.to_string(),
            size: 0,
            success: false,
            error: Some(format!("failed to request privileges: {e}")),
        },
    }
}

// ---------------------------------------------------------------------------
// Operation logging — every deletion is recorded to ~/.config/diskforge/history.log
// ---------------------------------------------------------------------------

/// Log a deletion operation to the history file.
fn log_operation(item: &CleanedItem) {
    let home = match std::env::var("HOME") {
        Ok(h) => h,
        Err(_) => return,
    };

    let log_dir = format!("{home}/.config/diskforge");
    let _ = fs::create_dir_all(&log_dir);
    let log_path = format!("{log_dir}/history.log");

    let Ok(mut file) = OpenOptions::new().create(true).append(true).open(&log_path) else {
        return;
    };

    let now = chrono::Local::now().format("%Y-%m-%d %H:%M:%S");
    let status = if item.success { "OK" } else { "FAIL" };
    let size_str = if item.size > 0 {
        format_size(item.size)
    } else {
        "0 B".into()
    };
    let error_str = item
        .error
        .as_deref()
        .map(|e| format!(" error={e}"))
        .unwrap_or_default();

    let _ = writeln!(
        file,
        "[{now}] {status} size={size_str} path={}{error_str}",
        item.path
    );
}