rclean-cli 0.2.0

Find and safely clean rebuildable developer artifacts across local workspaces
use std::fs;
use std::path::{Component, Path, PathBuf};

use crate::clean::SelectedCandidate;
use crate::error::PlanError;
use crate::model::{CandidateDraft, ProjectReport, Safety};
use crate::path_util::path_file_name;
use crate::rules;
use crate::scan::{
    dangerous_link_kind, is_docker_storage_path, is_protected_user_data_path,
    is_runtime_or_system_path,
};
use crate::user_rules::UserRuleSet;

use super::schema::{ActionPlan, PlanCandidate};

pub fn selected_from_action_plan(plan: &ActionPlan) -> Result<Vec<SelectedCandidate>, PlanError> {
    let mut selected = Vec::with_capacity(plan.selected.len());
    for candidate in &plan.selected {
        let path = PathBuf::from(&candidate.path);
        if candidate.requires_sudo {
            return Err(PlanError::Generic(requires_sudo_plan_reason(
                &candidate.path,
                &candidate.rule_id,
            )));
        }
        if is_protected_user_data_path(&path)
            && !rules::allows_protected_user_data_path(&candidate.rule_id)
        {
            return Err(PlanError::Generic(format!(
                "{} is protected user data; refusing to clean",
                candidate.path
            )));
        }
        if is_docker_storage_path(&path) {
            return Err(PlanError::Generic(format!(
                "{} is inside Docker daemon storage; refusing to clean",
                candidate.path
            )));
        }

        let draft = classify_plan_candidate(plan, candidate, &path).ok_or_else(|| {
            PlanError::Generic(format!(
                "{} is not recognized by any current rule (plan may be stale or tampered)",
                candidate.path
            ))
        })?;

        if is_runtime_or_system_path(&path) && !rules::is_global_rule(&draft.rule_id) {
            return Err(PlanError::Generic(format!(
                "{} is inside a protected runtime or system path; refusing to clean",
                candidate.path
            )));
        }

        if rules::requires_sudo(&draft.rule_id) {
            return Err(PlanError::Generic(requires_sudo_plan_reason(
                &candidate.path,
                &draft.rule_id,
            )));
        }

        if draft.safety == Safety::Blocked
            || draft.safety == Safety::Unknown
            || draft.safety == Safety::ReportOnly
        {
            return Err(PlanError::Generic(format!(
                "{} is now classified as {:?} by rule {}; refusing to clean",
                candidate.path, draft.safety, draft.rule_id
            )));
        }

        selected.push(SelectedCandidate {
            id: Some(candidate.id.clone()),
            path,
            bytes: candidate.bytes,
            rule_id: draft.rule_id,
            category: draft.category,
            safety: draft.safety,
            requires_sudo: rules::requires_sudo(&candidate.rule_id),
            risk_score: candidate.risk_score,
        });
    }
    Ok(selected)
}

fn requires_sudo_plan_reason(path: &str, rule_id: &str) -> String {
    format!(
        "{path} requires administrator access for rule {rule_id}; rclean will not run sudo or delete it. Review and remove it manually with administrator privileges if desired"
    )
}

pub fn revalidate_selected(
    plan: &ActionPlan,
    selected: &[SelectedCandidate],
) -> Result<(), PlanError> {
    let roots = plan
        .roots
        .iter()
        .filter_map(|root| PathBuf::from(root).canonicalize().ok())
        .collect::<Vec<_>>();
    if roots.is_empty() {
        return Err(PlanError::Generic(
            "action plan has no valid canonical roots".to_string(),
        ));
    }

    for candidate in selected {
        let metadata = fs::symlink_metadata(&candidate.path).map_err(|source| PlanError::Io {
            path: candidate.path.clone(),
            source,
        })?;
        if let Some(kind) = dangerous_link_kind(&metadata) {
            return Err(PlanError::Generic(format!(
                "{} is now a {}",
                candidate.path.display(),
                kind.description()
            )));
        }
        if !metadata.is_dir() {
            return Err(PlanError::Generic(format!(
                "{} is not a directory",
                candidate.path.display()
            )));
        }
        let canonical = candidate
            .path
            .canonicalize()
            .map_err(|source| PlanError::Io {
                path: candidate.path.clone(),
                source,
            })?;
        if is_protected_user_data_path(&canonical)
            && !rules::allows_protected_user_data_path(&candidate.rule_id)
        {
            return Err(PlanError::Generic(format!(
                "{} resolves to protected user data",
                candidate.path.display()
            )));
        }
        if is_docker_storage_path(&canonical) {
            return Err(PlanError::Generic(format!(
                "{} resolves inside Docker daemon storage",
                candidate.path.display()
            )));
        }
        if !roots.iter().any(|root| canonical.starts_with(root)) {
            return Err(PlanError::Generic(format!(
                "{} resolves outside the action plan roots",
                candidate.path.display()
            )));
        }
    }

    Ok(())
}

fn classify_plan_candidate(
    plan: &ActionPlan,
    candidate: &PlanCandidate,
    path: &Path,
) -> Option<CandidateDraft> {
    if let Some(draft) = classify_agent_tmp_worktree_from_plan(plan, candidate, path) {
        return Some(draft);
    }

    plan.projects
        .iter()
        .filter(|project| {
            project
                .candidates
                .iter()
                .any(|project_candidate| project_candidate.path == candidate.path)
        })
        .find_map(|project| classify_from_project_context(plan, project, path))
        .or_else(|| classify_from_path_parent(plan, path))
}

fn classify_agent_tmp_worktree_from_plan(
    plan: &ActionPlan,
    candidate: &PlanCandidate,
    path: &Path,
) -> Option<CandidateDraft> {
    if candidate.rule_id != "agent.tmp_worktree" || !is_immediate_child_of_tmp_plan_root(plan, path)
    {
        return None;
    }

    let parent = path.parent()?;
    let name = path_file_name(path)?;
    rules::classify_agent_tmp_worktree(parent, name, path)
}

fn is_immediate_child_of_tmp_plan_root(plan: &ActionPlan, path: &Path) -> bool {
    plan.roots.iter().map(PathBuf::from).any(|root| {
        is_allowed_tmp_plan_root(&root)
            && path.strip_prefix(&root).is_ok_and(|relative| {
                let mut components = relative.components();
                matches!(components.next(), Some(Component::Normal(_)))
                    && components.next().is_none()
            })
    })
}

fn is_allowed_tmp_plan_root(root: &Path) -> bool {
    let root = root.canonicalize().unwrap_or_else(|_| root.to_path_buf());
    candidate_tmp_roots()
        .into_iter()
        .filter_map(|tmp_root| tmp_root.canonicalize().ok())
        .any(|tmp_root| tmp_root == root)
}

fn candidate_tmp_roots() -> Vec<PathBuf> {
    if let Some(roots) = std::env::var_os("RCLEAN_TMP_ROOTS") {
        return std::env::split_paths(&roots).collect();
    }

    default_tmp_roots()
}

#[cfg(target_os = "macos")]
fn default_tmp_roots() -> Vec<PathBuf> {
    let mut roots = vec![std::env::temp_dir()];
    roots.push(PathBuf::from("/private/tmp"));
    roots.push(PathBuf::from("/tmp"));
    roots
}

#[cfg(target_os = "windows")]
fn default_tmp_roots() -> Vec<PathBuf> {
    vec![std::env::temp_dir()]
}

#[cfg(all(not(target_os = "macos"), not(target_os = "windows")))]
fn default_tmp_roots() -> Vec<PathBuf> {
    let mut roots = vec![std::env::temp_dir()];
    roots.push(PathBuf::from("/tmp"));
    roots
}

fn classify_from_project_context(
    plan: &ActionPlan,
    project: &ProjectReport,
    path: &Path,
) -> Option<CandidateDraft> {
    let project_dir = PathBuf::from(&project.path);
    let relative = path.strip_prefix(&project_dir).ok()?;
    let first_component = relative.components().next()?;
    let Component::Normal(name) = first_component else {
        return None;
    };
    let name = name.to_str()?;
    let classifier_path = project_dir.join(name);
    let draft = classify_from_project_rules(plan, &project_dir, name, classifier_path)?;
    (draft.path == path).then_some(draft)
}

fn classify_from_path_parent(plan: &ActionPlan, path: &Path) -> Option<CandidateDraft> {
    let parent = path.parent()?;
    let name = path_file_name(path)?;
    classify_from_project_rules(plan, parent, name, path.to_path_buf())
}

fn classify_from_project_rules(
    plan: &ActionPlan,
    project_dir: &Path,
    name: &str,
    path: PathBuf,
) -> Option<CandidateDraft> {
    rules::classify_candidate(project_dir, name, path)
        .or_else(|| classify_from_user_rules(plan, project_dir, name))
}

fn classify_from_user_rules(
    plan: &ActionPlan,
    project_dir: &Path,
    name: &str,
) -> Option<CandidateDraft> {
    let root = matching_plan_root(plan, project_dir)?;
    let user_rules = UserRuleSet::load_from_root(&root);
    if user_rules.is_empty() {
        return None;
    }
    user_rules.classify(name, project_dir)
}

fn matching_plan_root(plan: &ActionPlan, path: &Path) -> Option<PathBuf> {
    plan.roots
        .iter()
        .map(PathBuf::from)
        .filter(|root| path.starts_with(root))
        .max_by_key(|root| root.components().count())
}