403 lines
13 KiB
Rust
403 lines
13 KiB
Rust
//! The four engines behind squid: clean, uninstall, purge and disk analysis.
|
|
//!
|
|
//! Every engine follows the same contract:
|
|
//!
|
|
//! 1. **Scan** produces a [`ScanReport`] of [`CleanupItem`]s. Nothing is
|
|
//! deleted during a scan — scanning is always safe and always idempotent.
|
|
//! 2. **Delete** takes the items the user approved, re-validates each of them
|
|
//! against [`SafetyPolicy`] (never trusting the scan), and writes a ledger
|
|
//! session so `squid undo` can put Trash-mode deletions back.
|
|
//!
|
|
//! Engines never call `std::fs::remove_*` directly; that keeps the audit trail
|
|
//! and the safety net impossible to bypass.
|
|
|
|
pub mod analyze;
|
|
pub mod assets;
|
|
pub mod clean;
|
|
pub mod delete;
|
|
pub mod insights;
|
|
pub mod purge;
|
|
pub mod uninstall;
|
|
pub mod updates;
|
|
|
|
use globset::GlobMatcher;
|
|
use squid_core::settings::Settings;
|
|
use squid_core::{CleanupItem, SafetyPolicy, ScanReport};
|
|
use squid_platform::Platform;
|
|
use squid_rules::RuleSet;
|
|
use std::path::Path;
|
|
|
|
/// Shared dependencies for every engine: the OS adapter, user settings, the
|
|
/// rule set and the safety policy that guards every deletion.
|
|
pub struct Engine {
|
|
platform: Box<dyn Platform>,
|
|
settings: Settings,
|
|
safety: SafetyPolicy,
|
|
rules: RuleSet,
|
|
whitelist: Vec<GlobMatcher>,
|
|
settings_errors: Vec<String>,
|
|
}
|
|
|
|
impl Default for Engine {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl Engine {
|
|
pub fn new() -> Engine {
|
|
let (settings, settings_errors) = Settings::load();
|
|
Self::with_settings(settings, settings_errors)
|
|
}
|
|
|
|
pub fn with_settings(settings: Settings, settings_errors: Vec<String>) -> Engine {
|
|
let platform = squid_platform::current();
|
|
let rules = RuleSet::load(&settings);
|
|
let whitelist = settings.whitelist_matchers();
|
|
let mut safety = if is_root() {
|
|
SafetyPolicy::system()
|
|
} else {
|
|
SafetyPolicy::user_only()
|
|
};
|
|
if let Ok(mounts) = platform.volumes() {
|
|
safety = safety.with_mounts(
|
|
mounts
|
|
.into_iter()
|
|
.map(|volume| volume.mount_point)
|
|
.chain(platform.protected_prefixes())
|
|
.collect(),
|
|
);
|
|
}
|
|
Engine {
|
|
platform,
|
|
settings,
|
|
safety,
|
|
rules,
|
|
whitelist,
|
|
settings_errors,
|
|
}
|
|
}
|
|
|
|
pub fn platform(&self) -> &dyn Platform {
|
|
self.platform.as_ref()
|
|
}
|
|
|
|
pub fn settings(&self) -> &Settings {
|
|
&self.settings
|
|
}
|
|
|
|
pub fn settings_mut(&mut self) -> &mut Settings {
|
|
self.whitelist.clear();
|
|
&mut self.settings
|
|
}
|
|
|
|
/// Re-read whitelist/disabled rules after a settings change.
|
|
pub fn reload_settings(&mut self) {
|
|
let (settings, errors) = Settings::load();
|
|
self.settings = settings;
|
|
self.settings_errors = errors;
|
|
self.whitelist = self.settings.whitelist_matchers();
|
|
self.rules = RuleSet::load(&self.settings);
|
|
}
|
|
|
|
pub fn save_settings(&self) -> squid_core::Result<std::path::PathBuf> {
|
|
self.settings.save()
|
|
}
|
|
|
|
pub fn safety(&self) -> &SafetyPolicy {
|
|
&self.safety
|
|
}
|
|
|
|
pub fn rules(&self) -> &RuleSet {
|
|
&self.rules
|
|
}
|
|
|
|
pub fn settings_errors(&self) -> &[String] {
|
|
&self.settings_errors
|
|
}
|
|
|
|
pub fn is_whitelisted(&self, path: &Path) -> bool {
|
|
self.settings.is_whitelisted(path, &self.whitelist)
|
|
}
|
|
|
|
/// Why this item cannot be deleted, if it cannot. Rules pass the anchor they
|
|
/// declared; everything else falls back to the default anchors.
|
|
pub fn block_reason(&self, item: &CleanupItem) -> Option<String> {
|
|
// Mole's lesson: some directories *look* like caches but hold the
|
|
// user's own work — chat files, PWA offline data, IME dictionaries.
|
|
// They are refused even when a broad rule matched them, with the
|
|
// reason shown verbatim in the UI lock chip.
|
|
if let Some(reason) = crate::assets::asset_reason(&item.path) {
|
|
return Some(reason.to_string());
|
|
}
|
|
let anchors = if item.anchors.is_empty() {
|
|
squid_core::fs::default_anchors()
|
|
} else {
|
|
item.anchors.clone()
|
|
};
|
|
if self.is_whitelisted(&item.path) {
|
|
return Some("whitelisted".into());
|
|
}
|
|
self.safety.denies(&item.path, &anchors)
|
|
}
|
|
|
|
/// Mole's "re-verify at the last second" made visible: re-run every
|
|
/// deletion gate against the *current* item set and report what changed
|
|
/// since the scan. The confirm dialog shows the summary, so surprises
|
|
/// ("your app just started, we dropped 3 items") appear before the run,
|
|
/// not inside the results.
|
|
pub fn preflight(&self, report: &ScanReport, indexes: &[usize]) -> Preflight {
|
|
let running = self.platform().running_executables();
|
|
let mut out = Preflight {
|
|
checked: indexes.len(),
|
|
blocked: Vec::new(),
|
|
};
|
|
for &index in indexes {
|
|
let Some(item) = report.items.get(index) else {
|
|
continue;
|
|
};
|
|
if item.lock.is_some() {
|
|
continue;
|
|
}
|
|
if let Some(reason) = self.block_reason(item) {
|
|
out.blocked.push((item.display_path(), reason));
|
|
continue;
|
|
}
|
|
if let Some(path) = gone_path(item) {
|
|
out.blocked.push((
|
|
item.display_path(),
|
|
format!("{} 已不存在", squid_core::paths::pretty(&path)),
|
|
));
|
|
}
|
|
}
|
|
// Apps started since the scan: re-check running conflicts per rule.
|
|
for (index, item) in report.items.iter().enumerate() {
|
|
if item.lock.is_some() || !indexes.contains(&index) {
|
|
continue;
|
|
}
|
|
if let Some(rule) = self
|
|
.rules()
|
|
.rules()
|
|
.iter()
|
|
.find(|rule| rule.id == item.rule_id)
|
|
{
|
|
if let Some(conflict) = crate::clean::rule_running_conflict(rule, &running) {
|
|
if !out
|
|
.blocked
|
|
.iter()
|
|
.any(|(path, _)| *path == item.display_path())
|
|
{
|
|
out.blocked.push((item.display_path(), conflict));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Which whitelist patterns actually *do something* (Mole's #458: a
|
|
/// protection line nobody ever hits is a fake protection). A pattern is
|
|
/// "live" when it matches a path the current rule set finds on this
|
|
/// machine — the user learns their glob protects a real thing, or that
|
|
/// it protects nothing at all.
|
|
pub fn audit_whitelist(&self) -> Vec<(String, bool)> {
|
|
let known: Vec<std::path::PathBuf> = self
|
|
.rules()
|
|
.rules()
|
|
.iter()
|
|
.filter(|rule| rule.applies_to_current_os())
|
|
.flat_map(|rule| {
|
|
squid_rules::PreparedRule::new((*rule).clone())
|
|
.matches()
|
|
.into_iter()
|
|
.map(|matched| matched.path)
|
|
})
|
|
.collect();
|
|
// Same expansion the delete layer uses (settings.whitelist_matchers
|
|
// shape), rebuilt per pattern so an invalid line cannot shift the
|
|
// index pairing — the audit answers "does THIS pattern protect
|
|
// anything".
|
|
self.settings
|
|
.whitelist
|
|
.iter()
|
|
.map(|pattern| {
|
|
let live = Settings::whitelist_matcher_for(pattern).is_some_and(|matcher| {
|
|
known.iter().any(|path| matcher.is_match(path.as_path()))
|
|
});
|
|
(pattern.clone(), live)
|
|
})
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
/// Result of [`Engine::preflight`].
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct Preflight {
|
|
pub checked: usize,
|
|
/// (display path, reason) for items that can no longer be deleted.
|
|
pub blocked: Vec<(String, String)>,
|
|
}
|
|
|
|
fn gone_path(item: &squid_core::CleanupItem) -> Option<std::path::PathBuf> {
|
|
(!item.path.exists() && !std::fs::symlink_metadata(&item.path).is_ok())
|
|
.then(|| item.path.clone())
|
|
}
|
|
|
|
/// True when the process may touch system-owned paths.
|
|
#[cfg(unix)]
|
|
pub fn is_root() -> bool {
|
|
unsafe { libc::geteuid() == 0 }
|
|
}
|
|
|
|
#[cfg(not(unix))]
|
|
pub fn is_root() -> bool {
|
|
false
|
|
}
|
|
|
|
/// A path is writable by us when we are root, or we own it and can write it.
|
|
#[cfg(unix)]
|
|
pub fn writable_by_us(path: &Path) -> bool {
|
|
use std::os::unix::fs::MetadataExt;
|
|
if is_root() {
|
|
return true;
|
|
}
|
|
let uid = unsafe { libc::getuid() };
|
|
let writable = |meta: &std::fs::Metadata| meta.uid() == uid && meta.mode() & 0o200 != 0;
|
|
match std::fs::symlink_metadata(path) {
|
|
Ok(meta) if meta.file_type().is_symlink() => path
|
|
.parent()
|
|
.and_then(|parent| std::fs::metadata(parent).ok())
|
|
.map(|parent| writable(&parent))
|
|
.unwrap_or(false),
|
|
Ok(meta) => writable(&meta),
|
|
Err(_) => path
|
|
.parent()
|
|
.and_then(|parent| std::fs::metadata(parent).ok())
|
|
.map(|parent| writable(&parent))
|
|
.unwrap_or(false),
|
|
}
|
|
}
|
|
|
|
#[cfg(not(unix))]
|
|
pub fn writable_by_us(_path: &Path) -> bool {
|
|
true
|
|
}
|
|
|
|
/// Age of a path in days, using mtime. `None` when the stat failed.
|
|
pub fn age_days(path: &Path) -> Option<f64> {
|
|
let meta = std::fs::symlink_metadata(path).ok()?;
|
|
let modified = meta.modified().ok()?;
|
|
let age = modified.elapsed().ok()?;
|
|
Some(age.as_secs_f64() / 86_400.0)
|
|
}
|
|
|
|
pub fn mtime_ms(path: &Path) -> Option<u64> {
|
|
let meta = std::fs::symlink_metadata(path).ok()?;
|
|
let modified = meta.modified().ok()?;
|
|
modified
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.ok()
|
|
.map(|d| d.as_millis() as u64)
|
|
}
|
|
|
|
/// Drop items whose ancestor is already in the list: deleting the parent would
|
|
/// make the child's removal fail (and inflate the freed-space total).
|
|
pub fn drop_nested_duplicates(items: &mut Vec<CleanupItem>) {
|
|
items.sort_by(|a, b| a.path.cmp(&b.path));
|
|
let mut kept: Vec<CleanupItem> = Vec::with_capacity(items.len());
|
|
for item in items.drain(..) {
|
|
let nested = kept.iter().any(|parent: &CleanupItem| {
|
|
parent.path != item.path && starts_with(&item.path, &parent.path)
|
|
});
|
|
if !nested {
|
|
kept.push(item);
|
|
}
|
|
}
|
|
*items = kept;
|
|
}
|
|
|
|
fn starts_with(path: &Path, base: &Path) -> bool {
|
|
let mut path = path.components().peekable();
|
|
let mut base = base.components().peekable();
|
|
loop {
|
|
match (base.next(), path.next()) {
|
|
(Some(a), Some(b)) => {
|
|
if a != b {
|
|
return false;
|
|
}
|
|
}
|
|
(None, _) => return true,
|
|
(Some(_), None) => return false,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// "12,431 files · 382 folders" style annotation for the detail row.
|
|
pub fn size_note(info: &squid_core::fs::SizeInfo) -> String {
|
|
let files = squid_core::bytes::format_thousands(info.files);
|
|
if info.dirs > 0 {
|
|
format!(
|
|
"{files} files · {} folders",
|
|
squid_core::bytes::format_thousands(info.dirs)
|
|
)
|
|
} else {
|
|
format!("{files} files")
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use squid_core::{Category, ItemKind};
|
|
use std::path::PathBuf;
|
|
|
|
#[test]
|
|
fn nested_duplicates_are_collapsed() {
|
|
let mut items = vec![
|
|
CleanupItem::new(
|
|
PathBuf::from("/Users/x/Library/Caches"),
|
|
ItemKind::Path,
|
|
Category::AppCaches,
|
|
"caches",
|
|
),
|
|
CleanupItem::new(
|
|
PathBuf::from("/Users/x/Library/Caches/foo/bar"),
|
|
ItemKind::Path,
|
|
Category::AppCaches,
|
|
"nested",
|
|
),
|
|
CleanupItem::new(
|
|
PathBuf::from("/Users/x/Library/Logs"),
|
|
ItemKind::Path,
|
|
Category::Logs,
|
|
"logs",
|
|
),
|
|
];
|
|
drop_nested_duplicates(&mut items);
|
|
assert_eq!(items.len(), 2);
|
|
assert!(items
|
|
.iter()
|
|
.any(|item| item.path.ends_with("Library/Caches")));
|
|
assert!(items.iter().any(|item| item.path.ends_with("Library/Logs")));
|
|
}
|
|
|
|
#[test]
|
|
fn engine_boots_with_rules_and_volumes() {
|
|
let engine = Engine::new();
|
|
assert!(!engine.rules().is_empty(), "expected builtin rules to load");
|
|
assert!(!engine.settings_errors().is_empty() || true);
|
|
assert!(!engine.platform().display_name().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn safety_policy_blocks_the_obvious_roots() {
|
|
let engine = Engine::new();
|
|
let anchors = vec![PathBuf::from("/Users")];
|
|
assert!(engine.safety().denies(Path::new("/"), &anchors).is_some());
|
|
assert!(engine
|
|
.safety()
|
|
.denies(Path::new("/Users"), &anchors)
|
|
.is_some());
|
|
}
|
|
}
|