998 lines
31 KiB
Rust
998 lines
31 KiB
Rust
//! Tauri command surface for the desktop application.
|
|
//!
|
|
//! The UI never invents a deletion target. Scans are held in this process and
|
|
//! a delete command can only select indices from the scan that produced them.
|
|
//! The engine still re-validates every path against the same safety policy and
|
|
//! whitelist used by the CLI and TUI.
|
|
|
|
use squid_core::ledger::{self, Session};
|
|
use squid_core::paths;
|
|
use squid_core::progress::{CancelToken, Event, Progress};
|
|
use squid_core::{
|
|
AppInfo, Bytes, Category, CleanupItem, DeleteMode, ItemKind, Locale, LockReason, ScanReport,
|
|
Settings, UninstallPlan,
|
|
};
|
|
use squid_engine::analyze::{self, FileEntry, Node};
|
|
use squid_engine::delete::{self, DeleteJob, DeleteOutcome};
|
|
use squid_engine::{clean, purge, uninstall, Engine};
|
|
use squid_platform::PlatformId;
|
|
use squid_stats::{ProcessSample, Sampler, SystemSnapshot};
|
|
use std::collections::{HashMap, HashSet};
|
|
use std::path::PathBuf;
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::sync::{Arc, Mutex, MutexGuard};
|
|
use std::thread::{self, JoinHandle};
|
|
use std::time::{Duration, Instant};
|
|
use tauri::{AppHandle, Emitter, Manager};
|
|
|
|
#[derive(Default)]
|
|
pub struct AppState {
|
|
jobs: Mutex<HashMap<String, CancelToken>>,
|
|
scans: Mutex<HashMap<String, ScanReport>>,
|
|
plans: Mutex<HashMap<String, UninstallPlan>>,
|
|
apps: Mutex<Vec<AppInfo>>,
|
|
sampler: Mutex<Sampler>,
|
|
}
|
|
|
|
impl AppState {
|
|
fn lock<T>(value: &Mutex<T>) -> Result<MutexGuard<'_, T>, String> {
|
|
value
|
|
.lock()
|
|
.map_err(|_| "The application state is unavailable; restart Squid.".to_string())
|
|
}
|
|
|
|
pub(crate) fn begin(&self, job_id: &str) -> Result<CancelToken, String> {
|
|
if job_id.trim().is_empty() {
|
|
return Err("A job identifier is required.".into());
|
|
}
|
|
let token = CancelToken::new();
|
|
let mut jobs = Self::lock(&self.jobs)?;
|
|
jobs.insert(job_id.to_string(), token.clone());
|
|
Ok(token)
|
|
}
|
|
|
|
pub(crate) fn finish(&self, job_id: &str) {
|
|
if let Ok(mut jobs) = self.jobs.lock() {
|
|
jobs.remove(job_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct ProgressView {
|
|
job_id: String,
|
|
kind: String,
|
|
event: String,
|
|
phase: Option<String>,
|
|
detail: Option<String>,
|
|
done: Option<u64>,
|
|
total: Option<u64>,
|
|
subject: Option<String>,
|
|
freed: Option<u64>,
|
|
}
|
|
|
|
pub(crate) struct ProgressReporter {
|
|
stop: Arc<AtomicBool>,
|
|
handle: Option<JoinHandle<()>>,
|
|
}
|
|
|
|
impl ProgressReporter {
|
|
pub(crate) fn start(
|
|
app: AppHandle,
|
|
job_id: String,
|
|
kind: &'static str,
|
|
progress: Progress,
|
|
) -> Self {
|
|
let stop = Arc::new(AtomicBool::new(false));
|
|
let stopped = stop.clone();
|
|
let handle = thread::spawn(move || {
|
|
while !stopped.load(Ordering::Relaxed) {
|
|
if let Some(event) = progress.recv(Duration::from_millis(80)) {
|
|
emit_progress(&app, &job_id, kind, event);
|
|
}
|
|
}
|
|
for event in progress.drain() {
|
|
emit_progress(&app, &job_id, kind, event);
|
|
}
|
|
});
|
|
Self {
|
|
stop,
|
|
handle: Some(handle),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn finish(mut self) {
|
|
self.stop.store(true, Ordering::Relaxed);
|
|
if let Some(handle) = self.handle.take() {
|
|
let _ = handle.join();
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Drop for ProgressReporter {
|
|
fn drop(&mut self) {
|
|
self.stop.store(true, Ordering::Relaxed);
|
|
if let Some(handle) = self.handle.take() {
|
|
let _ = handle.join();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn emit_progress(app: &AppHandle, job_id: &str, kind: &str, event: Event) {
|
|
let payload = match event {
|
|
Event::Phase { phase, detail } => ProgressView {
|
|
job_id: job_id.into(),
|
|
kind: kind.into(),
|
|
event: "phase".into(),
|
|
phase: Some(phase.into()),
|
|
detail: Some(detail),
|
|
done: None,
|
|
total: None,
|
|
subject: None,
|
|
freed: None,
|
|
},
|
|
Event::Tick {
|
|
done,
|
|
total,
|
|
subject,
|
|
} => ProgressView {
|
|
job_id: job_id.into(),
|
|
kind: kind.into(),
|
|
event: "tick".into(),
|
|
phase: None,
|
|
detail: None,
|
|
done: Some(done),
|
|
total,
|
|
subject: subject.map(|path| paths::pretty(&path)),
|
|
freed: None,
|
|
},
|
|
Event::Note(note) => ProgressView {
|
|
job_id: job_id.into(),
|
|
kind: kind.into(),
|
|
event: "note".into(),
|
|
phase: None,
|
|
detail: Some(note),
|
|
done: None,
|
|
total: None,
|
|
subject: None,
|
|
freed: None,
|
|
},
|
|
Event::Warning(warning) => ProgressView {
|
|
job_id: job_id.into(),
|
|
kind: kind.into(),
|
|
event: "warning".into(),
|
|
phase: None,
|
|
detail: Some(warning),
|
|
done: None,
|
|
total: None,
|
|
subject: None,
|
|
freed: None,
|
|
},
|
|
Event::Deleted { path, freed } => ProgressView {
|
|
job_id: job_id.into(),
|
|
kind: kind.into(),
|
|
event: "deleted".into(),
|
|
phase: None,
|
|
detail: Some(paths::pretty(&path)),
|
|
done: None,
|
|
total: None,
|
|
subject: None,
|
|
freed: Some(freed.as_u64()),
|
|
},
|
|
Event::Bucket {
|
|
category,
|
|
total,
|
|
count,
|
|
} => ProgressView {
|
|
job_id: job_id.into(),
|
|
kind: kind.into(),
|
|
event: "bucket".into(),
|
|
phase: None,
|
|
detail: Some(format!("{}:{}:{}", category.id(), count, total.as_u64())),
|
|
done: None,
|
|
total: None,
|
|
subject: None,
|
|
freed: None,
|
|
},
|
|
Event::Done(_) => return,
|
|
};
|
|
let _ = app.emit("squid://progress", payload);
|
|
}
|
|
|
|
#[derive(Clone, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct CleanupItemView {
|
|
path: String,
|
|
display_path: String,
|
|
kind: ItemKind,
|
|
size: u64,
|
|
allocated: u64,
|
|
on_disk: u64,
|
|
category: Category,
|
|
label: String,
|
|
rule_id: String,
|
|
selected: bool,
|
|
lock: Option<LockReason>,
|
|
note: Option<String>,
|
|
}
|
|
|
|
impl From<&CleanupItem> for CleanupItemView {
|
|
fn from(item: &CleanupItem) -> Self {
|
|
Self {
|
|
path: item.path.to_string_lossy().to_string(),
|
|
display_path: item.display_path(),
|
|
kind: item.kind,
|
|
size: item.size.as_u64(),
|
|
allocated: item.allocated.as_u64(),
|
|
on_disk: item.on_disk().as_u64(),
|
|
category: item.category,
|
|
label: item.label.clone(),
|
|
rule_id: item.rule_id.clone(),
|
|
selected: item.selected,
|
|
lock: item.lock,
|
|
note: item.note.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct ScanView {
|
|
scan_id: String,
|
|
items: Vec<CleanupItemView>,
|
|
total: u64,
|
|
total_selected: u64,
|
|
selected_count: usize,
|
|
unreadable: u32,
|
|
elapsed_ms: u64,
|
|
}
|
|
|
|
fn scan_view(scan_id: String, report: &ScanReport, elapsed_ms: u64) -> ScanView {
|
|
let selected_total = report
|
|
.items
|
|
.iter()
|
|
.filter(|item| item.selected && item.lock.is_none())
|
|
.map(|item| item.on_disk().as_u64())
|
|
.sum();
|
|
ScanView {
|
|
scan_id,
|
|
items: report.items.iter().map(CleanupItemView::from).collect(),
|
|
total: report.total_all().as_u64(),
|
|
total_selected: selected_total,
|
|
selected_count: report
|
|
.items
|
|
.iter()
|
|
.filter(|item| item.selected && item.lock.is_none())
|
|
.count(),
|
|
unreadable: report.unreadable,
|
|
elapsed_ms,
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SkippedView {
|
|
path: String,
|
|
reason: String,
|
|
}
|
|
|
|
#[derive(Clone, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct DeleteResultView {
|
|
freed: u64,
|
|
freed_allocated: u64,
|
|
removed: usize,
|
|
failed: usize,
|
|
errors: Vec<String>,
|
|
mode: Option<DeleteMode>,
|
|
session_id: Option<String>,
|
|
skipped: Vec<SkippedView>,
|
|
}
|
|
|
|
impl DeleteResultView {
|
|
fn from_outcome(outcome: DeleteOutcome) -> Self {
|
|
Self {
|
|
freed: outcome.summary.freed.as_u64(),
|
|
freed_allocated: outcome.summary.freed_allocated.as_u64(),
|
|
removed: outcome.summary.removed,
|
|
failed: outcome.summary.failed,
|
|
errors: outcome.summary.errors,
|
|
mode: outcome.summary.mode,
|
|
session_id: outcome.summary.session_id,
|
|
skipped: outcome
|
|
.skipped
|
|
.into_iter()
|
|
.map(|(path, reason)| SkippedView {
|
|
path: paths::pretty(&path),
|
|
reason,
|
|
})
|
|
.collect(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SettingsView {
|
|
delete_mode: DeleteMode,
|
|
whitelist: Vec<String>,
|
|
purge_roots: Vec<String>,
|
|
purge_min_age_days: u64,
|
|
show_allocated: bool,
|
|
language: Option<String>,
|
|
effective_language: String,
|
|
history_keep: usize,
|
|
setup_reviewed: bool,
|
|
errors: Vec<String>,
|
|
}
|
|
|
|
impl SettingsView {
|
|
fn from_settings(settings: &Settings, errors: Vec<String>) -> Self {
|
|
Self {
|
|
delete_mode: settings.delete_mode,
|
|
whitelist: settings.whitelist.clone(),
|
|
purge_roots: settings.purge_roots.clone(),
|
|
purge_min_age_days: settings.purge_min_age_days,
|
|
show_allocated: settings.show_allocated,
|
|
language: settings.language.clone(),
|
|
effective_language: Locale::detect(settings).code().into(),
|
|
history_keep: settings.history_keep,
|
|
setup_reviewed: settings.desktop_setup_reviewed,
|
|
errors,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct BootstrapView {
|
|
version: String,
|
|
platform: String,
|
|
os_name: String,
|
|
os_version: String,
|
|
hardware: String,
|
|
arch: String,
|
|
device: String,
|
|
language: String,
|
|
bin_noun: String,
|
|
config_path: String,
|
|
history_path: String,
|
|
update_feed_url: String,
|
|
update_check_enabled: bool,
|
|
settings: SettingsView,
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn bootstrap() -> BootstrapView {
|
|
let (settings, errors) = Settings::load();
|
|
let engine = Engine::new();
|
|
let locale = squid_core::Locale::detect(&settings);
|
|
let prefs = crate::update::load_prefs();
|
|
BootstrapView {
|
|
version: env!("CARGO_PKG_VERSION").into(),
|
|
platform: PlatformId::current().as_str().into(),
|
|
os_name: engine.platform().display_name(),
|
|
os_version: engine.platform().os_version(),
|
|
hardware: engine.platform().hardware_model(),
|
|
arch: std::env::consts::ARCH.into(),
|
|
device: match engine.platform().device() {
|
|
squid_platform::Device::Mac => "mac".into(),
|
|
squid_platform::Device::Pc => "pc".into(),
|
|
squid_platform::Device::Machine => "machine".into(),
|
|
},
|
|
language: locale.code().into(),
|
|
bin_noun: match engine.platform().bin_noun() {
|
|
squid_platform::BinNoun::Trash => "trash".into(),
|
|
squid_platform::BinNoun::RecycleBin => "recycle-bin".into(),
|
|
},
|
|
config_path: Settings::path().to_string_lossy().to_string(),
|
|
history_path: ledger::history_dir().to_string_lossy().to_string(),
|
|
update_feed_url: crate::update::manifest_url(),
|
|
update_check_enabled: prefs.update_check_enabled,
|
|
settings: SettingsView::from_settings(&settings, errors),
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn cancel_job(app: AppHandle, job_id: String) -> bool {
|
|
let state = app.state::<AppState>();
|
|
let Ok(jobs) = AppState::lock(&state.jobs) else {
|
|
return false;
|
|
};
|
|
let Some(token) = jobs.get(&job_id) else {
|
|
return false;
|
|
};
|
|
token.cancel();
|
|
true
|
|
}
|
|
|
|
fn parse_categories(values: &[String]) -> Result<Vec<Category>, String> {
|
|
let mut categories = Vec::new();
|
|
for value in values {
|
|
let category =
|
|
Category::parse(value).ok_or_else(|| format!("Unknown cleanup category: {value}"))?;
|
|
if !categories.contains(&category) {
|
|
categories.push(category);
|
|
}
|
|
}
|
|
Ok(categories)
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn cleanup_scan(
|
|
app: AppHandle,
|
|
job_id: String,
|
|
categories: Vec<String>,
|
|
min_age_days: Option<u64>,
|
|
orphans: bool,
|
|
) -> Result<ScanView, String> {
|
|
let token = app.state::<AppState>().begin(&job_id)?;
|
|
let categories = parse_categories(&categories)?;
|
|
let progress = Progress::new();
|
|
let reporter =
|
|
ProgressReporter::start(app.clone(), job_id.clone(), "cleanup", progress.clone());
|
|
let started = Instant::now();
|
|
let task = tauri::async_runtime::spawn_blocking(move || {
|
|
let engine = Engine::new();
|
|
let options = clean::CleanOptions {
|
|
categories,
|
|
skip_admin_rules: true,
|
|
min_age_days,
|
|
orphans,
|
|
fast: false,
|
|
};
|
|
let report = clean::scan(&engine, &options, &progress, &token)?;
|
|
clean::publish_buckets(&report, &progress);
|
|
Ok::<ScanReport, squid_core::SquidError>(clean::sort_for_display(report))
|
|
})
|
|
.await
|
|
.map_err(|error| format!("Cleanup scan failed: {error}"))?;
|
|
reporter.finish();
|
|
app.state::<AppState>().finish(&job_id);
|
|
let report = task.map_err(|error| error.to_string())?;
|
|
let view = scan_view(
|
|
job_id.clone(),
|
|
&report,
|
|
started.elapsed().as_millis() as u64,
|
|
);
|
|
app.state::<AppState>()
|
|
.scans
|
|
.lock()
|
|
.map_err(|_| "The scan cache is unavailable.".to_string())?
|
|
.insert(job_id, report);
|
|
Ok(view)
|
|
}
|
|
|
|
fn select_indices(report: &mut ScanReport, selected: &[usize]) -> Result<(), String> {
|
|
let selected: HashSet<usize> = selected.iter().copied().collect();
|
|
if let Some(index) = selected.iter().find(|index| **index >= report.items.len()) {
|
|
return Err(format!("Selected item {index} is not in this scan."));
|
|
}
|
|
for (index, item) in report.items.iter_mut().enumerate() {
|
|
item.selected = selected.contains(&index) && item.lock.is_none();
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn cleanup_delete(
|
|
app: AppHandle,
|
|
job_id: String,
|
|
scan_id: String,
|
|
selected: Vec<usize>,
|
|
mode: DeleteMode,
|
|
) -> Result<DeleteResultView, String> {
|
|
let token = app.state::<AppState>().begin(&job_id)?;
|
|
let mut report = app
|
|
.state::<AppState>()
|
|
.scans
|
|
.lock()
|
|
.map_err(|_| "The scan cache is unavailable.".to_string())?
|
|
.get(&scan_id)
|
|
.cloned()
|
|
.ok_or_else(|| "This scan has expired. Run it again.".to_string())?;
|
|
select_indices(&mut report, &selected)?;
|
|
let items = report.items;
|
|
let progress = Progress::new();
|
|
let reporter = ProgressReporter::start(app.clone(), job_id.clone(), "delete", progress.clone());
|
|
let task = tauri::async_runtime::spawn_blocking(move || {
|
|
let engine = Engine::new();
|
|
let job = DeleteJob::new(items, mode, "Squid · Cleanup");
|
|
delete::execute(&engine, &job, &progress, &token)
|
|
})
|
|
.await
|
|
.map_err(|error| format!("Cleanup failed: {error}"))?;
|
|
reporter.finish();
|
|
app.state::<AppState>().finish(&job_id);
|
|
let outcome = task.map_err(|error| error.to_string())?;
|
|
if let Ok(mut scans) = app.state::<AppState>().scans.lock() {
|
|
scans.remove(&scan_id);
|
|
}
|
|
Ok(DeleteResultView::from_outcome(outcome))
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn purge_scan(
|
|
app: AppHandle,
|
|
job_id: String,
|
|
roots: Vec<String>,
|
|
min_age_days: Option<u64>,
|
|
force: bool,
|
|
) -> Result<ScanView, String> {
|
|
let token = app.state::<AppState>().begin(&job_id)?;
|
|
let progress = Progress::new();
|
|
let reporter = ProgressReporter::start(app.clone(), job_id.clone(), "purge", progress.clone());
|
|
let started = Instant::now();
|
|
let task = tauri::async_runtime::spawn_blocking(move || {
|
|
let engine = Engine::new();
|
|
let options = purge::PurgeOptions {
|
|
roots: roots.into_iter().map(|root| paths::expand(&root)).collect(),
|
|
min_age_days,
|
|
force,
|
|
max_depth: None,
|
|
};
|
|
let mut report = purge::scan(&engine, &options, &progress, &token)?;
|
|
report.items.sort_by(|a, b| {
|
|
b.on_disk()
|
|
.cmp(&a.on_disk())
|
|
.then_with(|| a.path.cmp(&b.path))
|
|
});
|
|
Ok::<ScanReport, squid_core::SquidError>(report)
|
|
})
|
|
.await
|
|
.map_err(|error| format!("Deep clean scan failed: {error}"))?;
|
|
reporter.finish();
|
|
app.state::<AppState>().finish(&job_id);
|
|
let report = task.map_err(|error| error.to_string())?;
|
|
let view = scan_view(
|
|
job_id.clone(),
|
|
&report,
|
|
started.elapsed().as_millis() as u64,
|
|
);
|
|
app.state::<AppState>()
|
|
.scans
|
|
.lock()
|
|
.map_err(|_| "The scan cache is unavailable.".to_string())?
|
|
.insert(job_id, report);
|
|
Ok(view)
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn purge_delete(
|
|
app: AppHandle,
|
|
job_id: String,
|
|
scan_id: String,
|
|
selected: Vec<usize>,
|
|
mode: DeleteMode,
|
|
) -> Result<DeleteResultView, String> {
|
|
let token = app.state::<AppState>().begin(&job_id)?;
|
|
let mut report = app
|
|
.state::<AppState>()
|
|
.scans
|
|
.lock()
|
|
.map_err(|_| "The scan cache is unavailable.".to_string())?
|
|
.get(&scan_id)
|
|
.cloned()
|
|
.ok_or_else(|| "This scan has expired. Run it again.".to_string())?;
|
|
select_indices(&mut report, &selected)?;
|
|
let items = report.items;
|
|
let progress = Progress::new();
|
|
let reporter = ProgressReporter::start(app.clone(), job_id.clone(), "delete", progress.clone());
|
|
let task = tauri::async_runtime::spawn_blocking(move || {
|
|
let engine = Engine::new();
|
|
let job = DeleteJob::new(items, mode, "Squid · Deep Clean");
|
|
delete::execute(&engine, &job, &progress, &token)
|
|
})
|
|
.await
|
|
.map_err(|error| format!("Deep clean failed: {error}"))?;
|
|
reporter.finish();
|
|
app.state::<AppState>().finish(&job_id);
|
|
let outcome = task.map_err(|error| error.to_string())?;
|
|
if let Ok(mut scans) = app.state::<AppState>().scans.lock() {
|
|
scans.remove(&scan_id);
|
|
}
|
|
Ok(DeleteResultView::from_outcome(outcome))
|
|
}
|
|
|
|
#[derive(Clone, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct AppsView {
|
|
apps: Vec<AppInfo>,
|
|
total: u64,
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn apps_scan(app: AppHandle, job_id: String) -> Result<AppsView, String> {
|
|
let token = app.state::<AppState>().begin(&job_id)?;
|
|
let progress = Progress::new();
|
|
let reporter = ProgressReporter::start(app.clone(), job_id.clone(), "apps", progress.clone());
|
|
let task = tauri::async_runtime::spawn_blocking(move || {
|
|
let engine = Engine::new();
|
|
uninstall::scan_apps(&engine, true, &progress, &token)
|
|
})
|
|
.await
|
|
.map_err(|error| format!("Application scan failed: {error}"))?;
|
|
reporter.finish();
|
|
app.state::<AppState>().finish(&job_id);
|
|
let apps = task.map_err(|error| error.to_string())?;
|
|
let total = apps.iter().map(|app| app.size.as_u64()).sum();
|
|
if let Ok(mut cache) = app.state::<AppState>().apps.lock() {
|
|
*cache = apps.clone();
|
|
}
|
|
Ok(AppsView { apps, total })
|
|
}
|
|
|
|
#[derive(Clone, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct PlanView {
|
|
plan_id: String,
|
|
app: AppInfo,
|
|
items: Vec<CleanupItemView>,
|
|
warnings: Vec<String>,
|
|
total: u64,
|
|
selected_count: usize,
|
|
selected_total: u64,
|
|
}
|
|
|
|
fn plan_view(plan_id: String, plan: &UninstallPlan) -> PlanView {
|
|
PlanView {
|
|
plan_id,
|
|
app: plan.app.clone(),
|
|
items: plan.items.iter().map(CleanupItemView::from).collect(),
|
|
warnings: plan.warnings.clone(),
|
|
total: plan.total().as_u64(),
|
|
selected_count: plan
|
|
.items
|
|
.iter()
|
|
.filter(|item| item.selected && item.lock.is_none())
|
|
.count(),
|
|
selected_total: plan
|
|
.items
|
|
.iter()
|
|
.filter(|item| item.selected && item.lock.is_none())
|
|
.map(|item| item.on_disk().as_u64())
|
|
.sum(),
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn app_plan(app: AppHandle, job_id: String, app_key: String) -> Result<PlanView, String> {
|
|
let chosen = app
|
|
.state::<AppState>()
|
|
.apps
|
|
.lock()
|
|
.map_err(|_| "The application inventory is unavailable.".to_string())?
|
|
.iter()
|
|
.find(|candidate| candidate.key() == app_key)
|
|
.cloned()
|
|
.ok_or_else(|| "That application is no longer in the inventory.".to_string())?;
|
|
let token = app.state::<AppState>().begin(&job_id)?;
|
|
let progress = Progress::new();
|
|
let reporter = ProgressReporter::start(app.clone(), job_id.clone(), "plan", progress.clone());
|
|
let task = tauri::async_runtime::spawn_blocking(move || {
|
|
let engine = Engine::new();
|
|
uninstall::build_plan(&engine, &chosen, &progress, &token)
|
|
})
|
|
.await
|
|
.map_err(|error| format!("Removal plan failed: {error}"))?;
|
|
reporter.finish();
|
|
app.state::<AppState>().finish(&job_id);
|
|
let plan = task.map_err(|error| error.to_string())?;
|
|
let view = plan_view(job_id.clone(), &plan);
|
|
app.state::<AppState>()
|
|
.plans
|
|
.lock()
|
|
.map_err(|_| "The removal plan cache is unavailable.".to_string())?
|
|
.insert(job_id, plan);
|
|
Ok(view)
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn app_uninstall(
|
|
app: AppHandle,
|
|
job_id: String,
|
|
plan_id: String,
|
|
selected: Vec<usize>,
|
|
mode: DeleteMode,
|
|
) -> Result<DeleteResultView, String> {
|
|
let token = app.state::<AppState>().begin(&job_id)?;
|
|
let mut plan = app
|
|
.state::<AppState>()
|
|
.plans
|
|
.lock()
|
|
.map_err(|_| "The removal plan cache is unavailable.".to_string())?
|
|
.get(&plan_id)
|
|
.cloned()
|
|
.ok_or_else(|| "This removal plan has expired. Build it again.".to_string())?;
|
|
let chosen: HashSet<usize> = selected.into_iter().collect();
|
|
if let Some(index) = chosen.iter().find(|index| **index >= plan.items.len()) {
|
|
return Err(format!("Selected item {index} is not in this plan."));
|
|
}
|
|
for (index, item) in plan.items.iter_mut().enumerate() {
|
|
item.selected = chosen.contains(&index) && item.lock.is_none();
|
|
}
|
|
let progress = Progress::new();
|
|
let reporter = ProgressReporter::start(app.clone(), job_id.clone(), "delete", progress.clone());
|
|
let task = tauri::async_runtime::spawn_blocking(move || {
|
|
let engine = Engine::new();
|
|
uninstall::remove_plan(&engine, &plan, mode, &progress, &token)
|
|
})
|
|
.await
|
|
.map_err(|error| format!("Uninstall failed: {error}"))?;
|
|
reporter.finish();
|
|
app.state::<AppState>().finish(&job_id);
|
|
let outcome = task.map_err(|error| error.to_string())?;
|
|
if let Ok(mut plans) = app.state::<AppState>().plans.lock() {
|
|
plans.remove(&plan_id);
|
|
}
|
|
Ok(DeleteResultView::from_outcome(outcome))
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn storage_explore(
|
|
app: AppHandle,
|
|
job_id: String,
|
|
path: Option<String>,
|
|
depth: Option<usize>,
|
|
top: Option<usize>,
|
|
) -> Result<Node, String> {
|
|
let token = app.state::<AppState>().begin(&job_id)?;
|
|
let progress = Progress::new();
|
|
let reporter =
|
|
ProgressReporter::start(app.clone(), job_id.clone(), "storage", progress.clone());
|
|
let root = path
|
|
.filter(|path| !path.trim().is_empty())
|
|
.map(|path| paths::expand(&path))
|
|
.unwrap_or_else(paths::home_dir);
|
|
if !root.is_dir() {
|
|
app.state::<AppState>().finish(&job_id);
|
|
reporter.finish();
|
|
return Err(format!("{} is not a folder.", root.display()));
|
|
}
|
|
let task = tauri::async_runtime::spawn_blocking(move || {
|
|
analyze::explore(
|
|
&root,
|
|
depth.unwrap_or(1).clamp(1, 3),
|
|
top.unwrap_or(16),
|
|
&token,
|
|
&progress,
|
|
)
|
|
})
|
|
.await
|
|
.map_err(|error| format!("Storage analysis failed: {error}"))?;
|
|
reporter.finish();
|
|
app.state::<AppState>().finish(&job_id);
|
|
task.map_err(|error| error.to_string())
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn storage_largest_files(
|
|
app: AppHandle,
|
|
job_id: String,
|
|
path: String,
|
|
limit: Option<usize>,
|
|
) -> Result<Vec<FileEntry>, String> {
|
|
let token = app.state::<AppState>().begin(&job_id)?;
|
|
let progress = Progress::new();
|
|
let reporter = ProgressReporter::start(app.clone(), job_id.clone(), "files", progress.clone());
|
|
let root = paths::expand(&path);
|
|
let task = tauri::async_runtime::spawn_blocking(move || {
|
|
analyze::largest_files(
|
|
&root,
|
|
limit.unwrap_or(40).clamp(1, 200),
|
|
Bytes(1_000_000),
|
|
&token,
|
|
&progress,
|
|
)
|
|
})
|
|
.await
|
|
.map_err(|error| format!("Large-file scan failed: {error}"))?;
|
|
reporter.finish();
|
|
app.state::<AppState>().finish(&job_id);
|
|
task.map_err(|error| error.to_string())
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn system_snapshot(app: AppHandle) -> Result<SystemSnapshot, String> {
|
|
let state = app.state::<AppState>();
|
|
let mut sampler = AppState::lock(&state.sampler)?;
|
|
Ok(sampler.refresh())
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn stop_process(app: AppHandle, process: ProcessSample) -> Result<(), String> {
|
|
let state = app.state::<AppState>();
|
|
let mut sampler = AppState::lock(&state.sampler)?;
|
|
sampler.stop(&process).map_err(|error| error.to_string())
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn history_list(limit: Option<usize>) -> Vec<Session> {
|
|
ledger::load_sessions(limit.unwrap_or(60).clamp(1, 500))
|
|
}
|
|
|
|
#[derive(Clone, serde::Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct UndoResultView {
|
|
restored: usize,
|
|
skipped: usize,
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn history_undo(session_id: String) -> Result<UndoResultView, String> {
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
let (restored, skipped) =
|
|
delete::restore_session(&session_id).map_err(|e| e.to_string())?;
|
|
Ok(UndoResultView { restored, skipped })
|
|
})
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
#[derive(Clone, serde::Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SettingsPatch {
|
|
delete_mode: Option<DeleteMode>,
|
|
language: Option<String>,
|
|
show_allocated: Option<bool>,
|
|
purge_min_age_days: Option<u64>,
|
|
history_keep: Option<usize>,
|
|
setup_reviewed: Option<bool>,
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn settings_save(app: AppHandle, patch: SettingsPatch) -> Result<SettingsView, String> {
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
let (mut settings, mut errors) = Settings::load();
|
|
if let Some(mode) = patch.delete_mode {
|
|
settings.delete_mode = mode;
|
|
}
|
|
if let Some(language) = patch.language {
|
|
let trimmed = language.trim();
|
|
settings.language = (!trimmed.is_empty()).then(|| trimmed.to_string());
|
|
}
|
|
if let Some(show) = patch.show_allocated {
|
|
settings.show_allocated = show;
|
|
}
|
|
if let Some(days) = patch.purge_min_age_days {
|
|
settings.purge_min_age_days = days.min(3650);
|
|
}
|
|
if let Some(keep) = patch.history_keep {
|
|
settings.history_keep = keep.clamp(5, 500);
|
|
}
|
|
if let Some(reviewed) = patch.setup_reviewed {
|
|
settings.desktop_setup_reviewed = reviewed;
|
|
}
|
|
settings
|
|
.save()
|
|
.map_err(|error| format!("Could not save settings: {error}"))?;
|
|
crate::sync_tray(&app, Locale::detect(&settings));
|
|
errors.retain(|error| !error.contains("config.toml"));
|
|
Ok(SettingsView::from_settings(&settings, errors))
|
|
})
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
fn escape_glob(text: &str) -> String {
|
|
let mut escaped = String::with_capacity(text.len());
|
|
for character in text.chars() {
|
|
if matches!(character, '*' | '?' | '[' | ']' | '{' | '}' | '!') {
|
|
escaped.push('\\');
|
|
}
|
|
escaped.push(character);
|
|
}
|
|
escaped
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn whitelist_add(path: String) -> Result<SettingsView, String> {
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
let (mut settings, errors) = Settings::load();
|
|
let expanded = paths::expand(&path);
|
|
if expanded.as_os_str().is_empty() {
|
|
return Err("Choose a path to protect.".into());
|
|
}
|
|
settings.add_whitelist(escape_glob(&paths::pretty(&expanded)));
|
|
settings
|
|
.save()
|
|
.map_err(|error| format!("Could not save settings: {error}"))?;
|
|
Ok(SettingsView::from_settings(&settings, errors))
|
|
})
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn whitelist_remove(pattern: String) -> Result<SettingsView, String> {
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
let (mut settings, errors) = Settings::load();
|
|
settings.remove_whitelist(&pattern);
|
|
settings
|
|
.save()
|
|
.map_err(|error| format!("Could not save settings: {error}"))?;
|
|
Ok(SettingsView::from_settings(&settings, errors))
|
|
})
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn reveal_path(app: AppHandle, path: String) -> Result<(), String> {
|
|
let target = PathBuf::from(path);
|
|
if !target.exists() {
|
|
return Err(format!("{} no longer exists.", target.display()));
|
|
}
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
crate::process::command("/usr/bin/open")
|
|
.arg("-R")
|
|
.arg(&target)
|
|
.status()
|
|
.map_err(|error| error.to_string())?;
|
|
}
|
|
#[cfg(windows)]
|
|
{
|
|
crate::process::command("explorer.exe")
|
|
.arg(format!("/select,{}", target.display()))
|
|
.status()
|
|
.map_err(|error| error.to_string())?;
|
|
}
|
|
#[cfg(not(any(target_os = "macos", windows)))]
|
|
{
|
|
crate::process::command("xdg-open")
|
|
.arg(target.parent().unwrap_or(Path::new("/")))
|
|
.status()
|
|
.map_err(|error| error.to_string())?;
|
|
}
|
|
let _ = app;
|
|
Ok(())
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn open_trash() -> Result<(), String> {
|
|
let platform = squid_platform::current();
|
|
platform.reveal_trash();
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn a_selected_index_can_never_select_a_locked_item() {
|
|
let mut report = ScanReport::default();
|
|
report.items.push(CleanupItem::new(
|
|
PathBuf::from("/tmp/keep"),
|
|
ItemKind::File,
|
|
Category::Logs,
|
|
"keep",
|
|
));
|
|
report.items.push(
|
|
CleanupItem::new(
|
|
PathBuf::from("/tmp/locked"),
|
|
ItemKind::File,
|
|
Category::Logs,
|
|
"locked",
|
|
)
|
|
.locked(LockReason::Protected),
|
|
);
|
|
select_indices(&mut report, &[0, 1]).unwrap();
|
|
assert!(report.items[0].selected);
|
|
assert!(!report.items[1].selected);
|
|
}
|
|
|
|
#[test]
|
|
fn an_out_of_range_selection_is_refused() {
|
|
let mut report = ScanReport::default();
|
|
assert!(select_indices(&mut report, &[0]).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn whitelist_paths_are_taken_literally() {
|
|
assert_eq!(escape_glob("~/Caches/[demo]*"), "~/Caches/\\[demo\\]\\*");
|
|
}
|
|
}
|