借鉴 Mole 的 12 项安全架构与交互全部落地;修复启动项开关失效

- 空间清理:扫描实时计数(已统计 N 文件 · X,进度封顶 99%);分类算完一个亮一个;
  清理点/文件行「X 未使用」休眠标签;node_modules 可删依据面板(锁文件/安装记录/
  手改检测/Git/年龄);低风险走底部绿色内联确认条(Esc 取消),对话框新增
  「刚刚逐路径复核过」审计面板;结果页按原因分组展示未处理项并给下一步按钮;
  清理清单导出 Markdown(含依据与受保护项)。
- 存储空间:新增「隐藏的吃空间大户」(更新缓存/休眠/页面文件/WinSxS/手机备份/旧下载);
  文件夹测量缓存 10 分钟 + 新鲜度标注 + 重新测量,删除后缓存自动作废。
- 引擎:微信/QQ 聊天文件、浏览器 IndexedDB 离线数据、搜狗词库等个人文件在扫描结果
  以待解锁行呈现且删除层强制拒删;preflight 删除前逐路径复核;白名单消费审计
  (设置页标注每条规则最近是否命中)。
- 修复:权限管理开机启动项开关点击无效/弹回——StartupApproved 标记改用最小注册表
  权限写入(原 KEY_ALL_ACCESS 在安全软件驻留的机器上直接被拒),拒绝访问时自动
  UAC 提权重试并回读核实;计划任务/服务同样支持提权通道;开关失败新增红色气泡。
- 无头浏览器 29 项点击断言全过;cargo test/clippy/fmt、pnpm check/build 全绿;0.1.10 重新打包。
dev
lijunjie 2026-11-20 18:54:02 +08:00
parent dccbe9b60a
commit e3eba338a7
32 changed files with 2504 additions and 119 deletions

View File

@ -594,7 +594,7 @@ fn with_progress<T>(
),
);
}
Event::Bucket { .. } | Event::Done(_) => {}
Event::Bucket { .. } | Event::Metered { .. } | Event::Done(_) => {}
}
}
if stop_now {

View File

@ -30,6 +30,8 @@ pub struct SizeInfo {
pub files: u64,
pub dirs: u64,
pub unreadable: u32,
/// Newest last-modified seen while walking (unix seconds). `0` = unknown.
pub newest_write: u64,
}
impl SizeInfo {
@ -56,6 +58,7 @@ impl SizeInfo {
self.files += other.files;
self.dirs += other.dirs;
self.unreadable += other.unreadable;
self.newest_write = self.newest_write.max(other.newest_write);
}
/// "12,431 files" style annotation for detail rows.
@ -207,6 +210,7 @@ pub fn measure(path: &Path, kind: ItemKind) -> SizeInfo {
if meta.file_type().is_symlink() {
info.files += 1;
info.logical += Bytes(meta.len());
info.newest_write = mtime_secs(&meta);
return info;
}
match kind {
@ -214,6 +218,7 @@ pub fn measure(path: &Path, kind: ItemKind) -> SizeInfo {
info.files += 1;
info.logical += Bytes(meta.len());
info.allocated += Bytes(allocated_bytes(path, &meta));
info.newest_write = mtime_secs(&meta);
return info;
}
ItemKind::Path | ItemKind::Contents => {}
@ -222,6 +227,7 @@ pub fn measure(path: &Path, kind: ItemKind) -> SizeInfo {
info.files += 1;
info.logical += Bytes(meta.len());
info.allocated += Bytes(allocated_bytes(path, &meta));
info.newest_write = mtime_secs(&meta);
return info;
}
@ -251,6 +257,7 @@ pub fn measure(path: &Path, kind: ItemKind) -> SizeInfo {
info.files += 1;
info.logical += Bytes(meta.len());
info.allocated += Bytes(allocated_bytes(entry.path(), &meta));
info.newest_write = info.newest_write.max(mtime_secs(&meta));
}
Err(_) => info.unreadable += 1,
}
@ -261,6 +268,14 @@ pub fn measure(path: &Path, kind: ItemKind) -> SizeInfo {
info
}
/// Last-modified as unix seconds; 0 when the platform withholds it.
fn mtime_secs(meta: &Metadata) -> u64 {
meta.modified()
.ok()
.and_then(|when| when.duration_since(std::time::UNIX_EPOCH).ok())
.map_or(0, |age| age.as_secs())
}
/// Measure many paths in parallel. `progress` receives completed units.
/// `Path` for folders (and anything that should be removed recursively),
/// `File` for plain files and symlinks.
@ -280,7 +295,7 @@ pub fn kind_of(path: &Path) -> crate::model::ItemKind {
pub fn measure_all(
targets: &[(PathBuf, ItemKind)],
cancel: &CancelToken,
on_unit: impl Fn(usize, &SizeInfo) + Send + Sync,
on_unit: impl Fn(usize, usize, &SizeInfo) + Send + Sync,
) -> Vec<SizeInfo> {
let pool = rayon::ThreadPoolBuilder::new()
.num_threads(measure_threads())
@ -297,14 +312,18 @@ pub fn measure_all(
let results: Vec<SizeInfo> = pool.install(|| {
targets
.par_iter()
.map(|(path, kind)| {
.enumerate()
.map(|(index, (path, kind))| {
if cancel.is_cancelled() {
cancelled.store(true, Ordering::Relaxed);
return SizeInfo::default();
}
let info = measure(path, *kind);
let idx = done.fetch_add(1, Ordering::Relaxed) as usize;
emit(idx, &info);
let completed = done.fetch_add(1, Ordering::Relaxed) as usize + 1;
// (target index, completed count): index identifies the unit —
// callbacks arrive in completion order under rayon — while the
// count drives monotonic progress bars.
emit(index, completed, &info);
info
})
.collect()
@ -369,6 +388,7 @@ pub fn remove_item_with(
files: 0,
dirs: 0,
unreadable: 0,
newest_write: 0,
};
Ok(freed.on_disk().max(Bytes::ZERO))
}

View File

@ -165,6 +165,21 @@ pub struct CleanupItem {
/// stale or hand-edited item can never escape its sandbox.
#[serde(default)]
pub anchors: Vec<PathBuf>,
/// Seconds since the *most recent* last-write inside the item (Mole's
/// decision aid: 1.2 GB alone is not actionable, "untouched for 3 months"
/// is — and a low value flags a live, working directory). Unknown until
/// measurement; `None` for unreadable paths.
#[serde(default)]
pub last_write_secs: Option<u64>,
/// File count from measurement — lets the UI say "12 files · 5 folders".
#[serde(default)]
pub file_count: u64,
/// Machine-readable judgement tokens (Mole's evidence chain, made
/// visible): `lock:<file>`, `record:<file>`, `record-missing`,
/// `modified:<n>`, `git:ignored|untracked|none|tracked`, `age:<days>`,
/// `busy`. The UI renders each token as a ✓/! line in a detail panel.
#[serde(default)]
pub evidence: Vec<String>,
}
impl CleanupItem {
@ -187,6 +202,9 @@ impl CleanupItem {
lock: lock_default(kind),
note: None,
anchors: Vec::new(),
last_write_secs: None,
file_count: 0,
evidence: Vec::new(),
}
}

View File

@ -30,6 +30,12 @@ pub enum Event {
total: Bytes,
count: usize,
},
/// Cumulative measurement counters, streamed while sizes are computed
/// (Mole's "Scanning: 128,431 files · 38.2 GB" live status line).
Metered {
files: u64,
bytes: Bytes,
},
Deleted {
path: PathBuf,
freed: Bytes,

View File

@ -161,6 +161,13 @@ impl Settings {
.collect()
}
/// One raw whitelist line as a matcher — the shape the audit layer
/// needs when it must answer about a single pattern, not the list.
pub fn whitelist_matcher_for(raw: &str) -> Option<GlobMatcher> {
let expanded = paths::expand(raw).to_string_lossy().into_owned();
Glob::new(&expanded).ok().map(|g| g.compile_matcher())
}
pub fn is_whitelisted(&self, path: &Path, matchers: &[GlobMatcher]) -> bool {
if self.whitelist.is_empty() {
return false;

View File

@ -16,6 +16,7 @@ use std::path::{Path, PathBuf};
const CHILD_CAP: usize = 512;
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Node {
pub path: PathBuf,
pub logical: Bytes,
@ -196,9 +197,9 @@ pub fn expand(
})
.collect();
progress.tick(0, Some(targets.len() as u64), None);
let sizes = fs::measure_all(&targets, cancel, |index, _info| {
let sizes = fs::measure_all(&targets, cancel, |index, completed, _info| {
progress.tick(
index as u64 + 1,
completed as u64,
Some(targets.len() as u64),
targets.get(index).map(|(path, _)| path.clone()),
);

View File

@ -0,0 +1,190 @@
//! User-asset recognition — the Mole `app_protection` lesson for Windows.
//!
//! Some directories look exactly like caches but hold the user's own work:
//! chat files inside an IM data folder, PWA offline documents in a browser
//! profile's IndexedDB,输入法词库. A broad rule (or an eager user) must never
//! sweep them away, so they are pinned here: the scan lists them as locked,
//! visibly-explained rows, and the delete layer refuses them even when a
//! stale report still claims they are removable.
use squid_core::{Category, CleanupItem, ItemKind};
use std::path::Path;
/// Lower-cased path fragment → human reason. Matching is on the *normalised*
/// (lower-case, `/`→`\`) path so one table covers every drive letter and user.
const ASSET_MARKERS: &[(&str, &str)] = &[
(
"\\appdata\\roaming\\texact\\",
"腾讯 QQ 数据目录(聊天记录与文件)",
),
(
"\\appdata\\roaming\\tencent\\",
"腾讯通用数据目录(聊天文件与配置)",
),
(
"\\documents\\weixin files\\filestorage",
"微信聊天文件与下载文档",
),
(
"\\appdata\\roaming\\weixin\\filestorage",
"微信聊天文件与下载文档",
),
("\\appdata\\roaming\\txdnd\\", "腾讯游戏数据目录"),
("\\sogouexplorer\\", "搜狗输入法词库与用户习惯"),
(
"\\appdata\\roaming\\sogouinput\\",
"搜狗输入法词库与用户习惯",
),
];
/// Browser profile storage that holds PWA / offline web app documents —
/// Mole's `PROTECTED_SW_DOMAINS` equivalent. An `IndexedDB` folder inside a
/// Chromium-family browser profile is user work data (Figma / 剪映网页版 save
/// there), unlike `Cache` which is pure rebuildable bytes.
const CHROMIUM_PROFILE_MARKERS: &[&str] = &[
"\\microsoft\\edge\\user data\\",
"\\google\\chrome\\user data\\",
"\\chromium\\application\\user data\\",
];
fn normalise(path: &Path) -> String {
path.to_string_lossy().to_lowercase().replace('/', "\\")
}
/// Why this path is untouchable user property, if it is. The note lands in
/// the UI lock chip's explanation, mirroring 电脑管家's "创建者" honesty.
pub fn asset_reason(path: &Path) -> Option<&'static str> {
let lower = normalise(path);
// Deeper profile sub-paths (…\IndexedDB\foo) stay protected too: match
// the marker as a path prefix at a separator boundary.
if lower.contains("\\indexeddb")
&& CHROMIUM_PROFILE_MARKERS
.iter()
.any(|marker| lower.starts_with(marker) || lower.contains(marker))
{
return Some("可能含离线应用数据(Figma / 剪映网页版等工作文件)");
}
ASSET_MARKERS
.iter()
.find(|(marker, _)| segment_match(&lower, marker))
.map(|(_, reason)| *reason)
}
/// True when `marker` appears inside `lower` at path segment boundaries.
/// Markers ending with a separator carry their own trailing boundary, so
/// `TencentGame\cache` must not match `\tencent\`.
fn segment_match(lower: &str, marker: &str) -> bool {
if marker.ends_with('\\') {
return lower.contains(marker);
}
lower.match_indices(marker).any(|(index, _)| {
// A marker that opens with `\` carries its own left boundary; a bare
// marker needs a separator (or drive colon) before it.
let before_ok = index == 0
|| marker.starts_with('\\')
|| matches!(lower.as_bytes()[index - 1], b'\\' | b':');
let after = index + marker.len();
let after_ok = lower.len() == after || lower.as_bytes().get(after) == Some(&b'\\');
before_ok && after_ok
})
}
/// Asset rows to surface in the 空间清理 list — existence checked, one row
/// per top-level asset. Rows anchor at their own parent: they are display
/// only (locked), and anchoring at the folder itself would make
/// `block_reason` deny the row's own deletion check.
pub fn known_asset_rows() -> Vec<CleanupItem> {
const SPECS: [(&str, &str); 6] = [
(
r"AppData\Roaming\Tencent",
"腾讯(QQ/微信旧版)数据目录(聊天记录与文件)",
),
(
r"Documents\WeChat Files",
"微信聊天文件与下载文档(旧版目录)",
),
(
r"Documents\Weixin Files\FileStorage",
"微信聊天文件与下载文档",
),
(r"AppData\Roaming\SogouInput", "搜狗输入法词库与用户习惯"),
(
r"AppData\Local\Microsoft\Edge\User Data\Default\IndexedDB",
"可能含离线应用数据(Figma / 剪映网页版等工作文件)",
),
(
r"AppData\Local\Google\Chrome\User Data\Default\IndexedDB",
"可能含离线应用数据(Figma / 剪映网页版等工作文件)",
),
];
let Ok(home) = std::env::var("USERPROFILE") else {
return Vec::new();
};
let home = Path::new(&home);
let mut rows = Vec::new();
for (tail, reason) in SPECS {
let path = home.join(tail);
if !path.is_dir() {
continue;
}
let label = format!("🔒 {}", asset_label(&path));
let parent = path
.parent()
.map(|dir| dir.to_path_buf())
.unwrap_or_else(|| path.clone());
let item = CleanupItem::new(path, ItemKind::Path, Category::AppCaches, label)
.with_rule("user-assets")
.with_anchors(std::iter::once(parent))
.locked(squid_core::LockReason::Protected)
.with_note(reason);
rows.push(item);
}
rows
}
fn asset_label(path: &Path) -> String {
let text = squid_core::paths::pretty(path);
text.rsplit(['\\', '/'])
.next()
.filter(|leaf| !leaf.is_empty())
.unwrap_or(&text)
.to_string()
}
#[cfg(test)]
mod tests {
use super::*;
use std::path::PathBuf;
#[test]
fn im_data_dirs_refuse_deletion_with_a_reason() {
let path = PathBuf::from(r"C:\Users\me\AppData\Roaming\Tencent\WeChat\111\msg");
let reason = asset_reason(&path).expect("QQ tree must be protected");
assert!(reason.contains("聊天"));
}
#[test]
fn wechat_file_storage_is_protected_but_cache_paths_are_not() {
let storage = PathBuf::from(r"D:\Users\me\Documents\Weixin Files\FileStorage\File\2026-01");
assert!(asset_reason(&storage).is_some());
let edge_cache =
PathBuf::from(r"C:\Users\me\AppData\Local\Microsoft\Edge\User Data\Default\Cache");
assert!(asset_reason(&edge_cache).is_none());
}
#[test]
fn profile_indexeddb_counts_as_offline_app_data() {
let pwa = PathBuf::from(
r"C:\Users\me\AppData\Local\Microsoft\Edge\User Data\Default\IndexedDB\figma_0.indexeddb.leveldb",
);
let reason = asset_reason(&pwa).expect("PWA data must be protected");
assert!(reason.contains("离线应用"));
}
#[test]
fn markers_match_only_at_segment_boundaries() {
// A folder that merely *starts* with the marker text is not the asset.
let sneaky = PathBuf::from(r"C:\Users\me\AppData\Roaming\TencentGame\cache");
assert!(asset_reason(&sneaky).is_none());
}
}

View File

@ -172,6 +172,20 @@ pub fn scan(
}
}
// User-asset rows (B4): pinned directories shown as locked, explained
// rows so "why can't I clean my WeChat files?" never becomes a mystery.
let assets_wanted =
options.categories.is_empty() || options.categories.contains(&Category::AppCaches);
if assets_wanted {
for item in crate::assets::known_asset_rows() {
if seen.contains_key(&item.path) {
continue;
}
seen.insert(item.path.clone(), report.items.len());
report.items.push(item);
}
}
if !options.fast {
measure(engine, &mut report, progress, cancel)?;
}
@ -201,7 +215,7 @@ fn prepared_rules(engine: &Engine, options: &CleanOptions) -> Vec<PreparedRule>
rules.into_iter().map(PreparedRule::new).collect()
}
fn rule_running_conflict(rule: &Rule, running: &[String]) -> Option<String> {
pub fn rule_running_conflict(rule: &Rule, running: &[String]) -> Option<String> {
if rule.skip_if_running.is_empty() {
return None;
}
@ -334,15 +348,42 @@ fn measure(
.iter()
.map(|item| (item.path.clone(), item.kind))
.collect();
progress.tick(0, Some(targets.len() as u64), None);
let total = targets.len() as u64;
progress.tick(0, Some(total), None);
let results: Vec<squid_core::fs::SizeInfo> = measure_all(&targets, cancel, |index, _info| {
progress.tick(
index as u64 + 1,
Some(targets.len() as u64),
targets.get(index).map(|(path, _)| path.clone()),
);
});
// Cumulative counters for the live status line; the callback runs on
// rayon worker threads, hence the mutex. Emissions are throttled to
// ~10/s so the IPC stays a whisper while the walk screams.
let meter = std::sync::Mutex::new((0u64, 0u64, std::time::Instant::now()));
let results: Vec<squid_core::fs::SizeInfo> =
measure_all(&targets, cancel, |index, completed, info| {
let emit_line = {
let mut guard = meter
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
guard.0 += info.files;
guard.1 += info.on_disk().as_u64();
if completed as u64 == total
|| guard.2.elapsed() >= std::time::Duration::from_millis(90)
{
guard.2 = std::time::Instant::now();
Some((guard.0, guard.1))
} else {
None
}
};
if let Some((files, bytes)) = emit_line {
progress.publish(Event::Metered {
files,
bytes: Bytes(bytes),
});
}
progress.tick(
completed as u64,
Some(total),
targets.get(index).map(|(path, _)| path.clone()),
);
});
if results.len() != report.items.len() {
return Err(SquidError::Other(
"measurement returned an unexpected number of results".into(),
@ -351,6 +392,17 @@ fn measure(
for (item, info) in report.items.iter_mut().zip(results) {
item.size = info.logical;
item.allocated = info.allocated;
item.file_count = info.files;
// "Untouched for X" is the actionable half of a size figure; derived
// from the newest last-write seen during the walk we just did.
item.last_write_secs = if info.newest_write == 0 {
None
} else {
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |since| since.as_secs());
Some(now.saturating_sub(info.newest_write))
};
if info.unreadable > 0 && item.note.is_none() {
item.note = Some(format!("{} entries unreadable", info.unreadable));
} else if info.files > 0 && item.note.is_none() {

View File

@ -0,0 +1,197 @@
//! Hidden-space insights (Mole's `cmd/analyze` overview idiom).
//!
//! The disk analyzer answers "what is big"; this answers "what is big *and*
//! actionable" — curated Windows space hogs with a one-line explanation and
//! the action that actually frees them. Existence-gated: a row appears only
//! when the underlying path (or state) is really on this machine.
use serde::Serialize;
use squid_core::fs;
use std::path::{Path, PathBuf};
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Insight {
/// Stable id for the UI (icon/translation lookup).
pub id: String,
pub title: String,
pub path: String,
pub size: u64,
/// "cleanable" — 空间清理 covers it; "command" — needs the given command;
/// "external" — system tool territory; "info" — informational.
pub action: String,
/// Command to run (elevated) when action == "command".
pub command: Option<String>,
pub hint: String,
}
fn home() -> Option<PathBuf> {
std::env::var("USERPROFILE")
.ok()
.map(PathBuf::from)
.filter(|path| path.is_dir())
}
fn dir_size(path: &Path) -> u64 {
if !path.is_dir() {
return 0;
}
fs::measure(path, squid_core::ItemKind::Path)
.on_disk()
.as_u64()
}
fn file_size(path: &Path) -> u64 {
std::fs::metadata(path).map_or(0, |meta| meta.len())
}
/// All insights that currently exist on this machine, biggest-effect first
/// ordering is left to the UI.
pub fn collect() -> Vec<Insight> {
let mut out = Vec::new();
let Some(home) = home() else {
return out;
};
let system = std::env::var("SystemRoot").unwrap_or_else(|_| r"C:\Windows".into());
let system = PathBuf::from(system);
// 1. Windows Update download cache — the classic 5-20 GB surprise.
let updates = system.join(r"SoftwareDistribution\Download");
let size = dir_size(&updates);
if size > 256 * 1024 * 1024 {
out.push(Insight {
id: "update-cache".into(),
title: "Windows 更新缓存".into(),
path: updates.display().to_string(),
size,
action: "cleanable".into(),
command: None,
hint: "已安装的更新包,Windows 需要时会重新下载;空间清理的「系统垃圾」覆盖此目录"
.into(),
});
}
// 2. Hibernation file — freed by turning hibernation off.
let hiber = system.join("..\\hiberfil.sys");
let size = file_size(&hiber);
if size > 0 {
out.push(Insight {
id: "hiberfil".into(),
title: "休眠文件 hiberfil.sys".into(),
path: hiber.display().to_string(),
size,
action: "command".into(),
command: Some("powercfg /h off".into()),
hint: "关闭休眠后系统自动删除;睡眠不受影响".into(),
});
}
// 3. Pagefile — visible but rarely worth touching; info only.
let page = system.join("..\\pagefile.sys");
let size = file_size(&page);
if size > 0 {
out.push(Insight {
id: "pagefile".into(),
title: "虚拟内存 pagefile.sys".into(),
path: page.display().to_string(),
size,
action: "info".into(),
command: None,
hint: "系统正在使用的虚拟内存,不建议手动删除;可在系统设置改到别的盘".into(),
});
}
// 4. Component store (WinSxS) — needs DISM, never raw deletion.
// Walking 100k+ files just to print a number is not worth it here;
// the UI shows "several GB" and the DISM command does the rest.
let winsxs = system.join("WinSxS");
if winsxs.is_dir() {
out.push(Insight {
id: "winsxs".into(),
title: "组件存储 WinSxS".into(),
path: winsxs.display().to_string(),
size: 0,
action: "command".into(),
command: Some("Dism.exe /online /Cleanup-Image /StartComponentCleanup".into()),
hint: "系统组件仓库,通常 5~10 GB;只能由 DISM 收缩,直接删会破坏系统".into(),
});
}
// 5. Phone backups (Apple MobileSync / third-party Android tools).
for (tail, title) in [
(r"Apple\MobileSync\Backup", "iPhone 备份"),
(r"Apple Computer\MobileSync\Backup", "iPhone 备份"),
] {
let backups = home.join(tail);
let size = dir_size(&backups);
if size > 256 * 1024 * 1024 {
out.push(Insight {
id: "phone-backup".into(),
title: title.into(),
path: backups.display().to_string(),
size,
action: "external".into(),
command: None,
hint: "整机备份体积大;确认 iCloud 或新备份完成后,在 iTunes/Finder 里删除旧备份"
.into(),
});
break;
}
}
// 6. Downloads older than 90 days (Mole's "Old Downloads" insight).
let downloads = home.join("Downloads");
if downloads.is_dir() {
let cutoff = std::time::SystemTime::now() - std::time::Duration::from_secs(90 * 24 * 3600);
let mut size = 0u64;
let mut stale = 0usize;
if let Ok(entries) = std::fs::read_dir(&downloads) {
for entry in entries.flatten() {
let meta = match entry.metadata() {
Ok(meta) => meta,
Err(_) => continue,
};
let modified = meta.modified().unwrap_or(std::time::UNIX_EPOCH);
if modified < cutoff {
size += if meta.is_dir() {
dir_size(&entry.path())
} else {
meta.len()
};
stale += 1;
}
}
}
if size > 256 * 1024 * 1024 {
out.push(Insight {
id: "old-downloads".into(),
title: "下载文件夹(90 天以上)".into(),
path: downloads.display().to_string(),
size,
action: "external".into(),
command: None,
hint: format!("{stale} 个条目三个月没动过;确认不再需要后手动清理"),
});
}
}
out.sort_by_key(|row| std::cmp::Reverse(row.size));
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn collect_never_panics_on_a_live_machine() {
// Pure smoke: whatever exists, ids are unique and sizes sane.
let rows = collect();
for (index, row) in rows.iter().enumerate() {
assert!(!row.id.is_empty());
assert!(!rows[..index]
.iter()
.any(|earlier| earlier.id == row.id && row.id != "phone-backup"));
}
}
}

View File

@ -12,15 +12,17 @@
//! 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};
use squid_core::{CleanupItem, SafetyPolicy, ScanReport};
use squid_platform::Platform;
use squid_rules::RuleSet;
use std::path::Path;
@ -121,6 +123,13 @@ impl Engine {
/// 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 {
@ -131,6 +140,107 @@ impl Engine {
}
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.

View File

@ -222,11 +222,13 @@ pub fn scan(
);
let mut item = item_for(candidate);
// Evidence chain (B3): remember the git verdict + project root + age
// while checking, then attach machine tokens for the UI panel.
let evidence_project =
project_with_git(&candidate.path).unwrap_or_else(|| candidate.project.clone());
let evidence_age = age_days(&candidate.path);
if !options.force {
let project_root = match project_with_git(&candidate.path) {
Some(dir) => dir,
None => candidate.project.clone(),
};
let project_root = evidence_project.clone();
let state = match git_cache.iter().find(|(dir, _)| *dir == project_root) {
Some((_, state)) => *state,
None => {
@ -237,14 +239,22 @@ pub fn scan(
};
match state {
GitState::Tracked => {
item.evidence.push("git:tracked".into());
item = item
.locked(LockReason::Protected)
.with_note("tracked by git — pass --all to delete anyway");
}
GitState::Ignored => item.note = Some("git-ignored build output".into()),
GitState::Untracked => item.note = Some("untracked by git".into()),
GitState::Ignored => {
item.evidence.push("git:ignored".into());
item.note = Some("git-ignored build output".into());
}
GitState::Untracked => {
item.evidence.push("git:untracked".into());
item.note = Some("untracked by git".into());
}
GitState::Unknown => {
let age = age_days(&candidate.path);
item.evidence.push("git:none".into());
let age = evidence_age;
match age {
Some(age) if age >= min_age as f64 => {
item.note = Some(format!("no git repo · {:.0} days old", age));
@ -288,6 +298,7 @@ pub fn scan(
.locked(LockReason::NotOwned)
.with_note("owned by another user");
}
collect_evidence(&mut item, &evidence_project, evidence_age);
report.items.push(item);
}
@ -310,6 +321,77 @@ pub fn scan(
Ok(report)
}
/// Mole's node_modules evidence chain, made visible (B3):
/// a lockfile proves the tree is *reinstallable*; the package manager's
/// install record inside the artefact proves nobody hand-edited it since —
/// any file newer than the record smells like patched code, so we count it.
/// Returns machine tokens for the UI detail panel; empty = not a node tree.
fn node_evidence(project: &Path, artifact: &Path) -> Vec<String> {
const LOCKS: [(&str, &str); 3] = [
("package-lock.json", ".package-lock.json"),
("pnpm-lock.yaml", ".modules.yaml"),
("yarn.lock", ".yarn-integrity"),
];
let mut out = Vec::new();
let Some((lock, record)) = LOCKS.iter().find(|(lock, _)| project.join(lock).is_file()) else {
return out;
};
out.push(format!("lock:{lock}"));
let record_path = artifact.join(record);
let Ok(meta) = std::fs::metadata(&record_path) else {
out.push("record-missing".into());
return out;
};
out.push(format!("record:{record}"));
let Ok(stamp) = meta.modified() else {
return out;
};
let mut modified = 0u32;
let mut seen = 0u32;
for entry in walkdir::WalkDir::new(artifact)
.follow_links(false)
.max_depth(8)
.into_iter()
.filter_map(Result::ok)
{
if !entry.file_type().is_file() {
continue;
}
seen += 1;
if entry
.metadata()
.ok()
.and_then(|file| file.modified().ok())
.is_some_and(|when| when > stamp)
{
modified += 1;
if modified > 50 {
break;
}
}
if seen >= 40_000 {
break;
}
}
out.push(format!("modified:{modified}"));
out
}
/// Collect the evidence tokens for one candidate after its checks ran.
fn collect_evidence(item: &mut CleanupItem, project: &Path, age: Option<f64>) {
if let Some(age) = age {
item.evidence.push(format!("age:{}", age.floor() as u64));
}
let name = item
.path
.file_name()
.map(|name| name.to_string_lossy().to_lowercase())
.unwrap_or_default();
if name == "node_modules" {
item.evidence.extend(node_evidence(project, &item.path));
}
}
fn item_for(candidate: &Candidate) -> CleanupItem {
let category = if candidate.name.eq_ignore_ascii_case("DerivedData") {
Category::Developer
@ -554,9 +636,31 @@ fn measure(report: &mut ScanReport, progress: &Progress, cancel: &CancelToken) {
return;
}
progress.phase("measure", "measuring artefacts");
let sizes = squid_core::fs::measure_all(&targets, cancel, |index, _info| {
let meter = std::sync::Mutex::new((0u64, 0u64, std::time::Instant::now()));
let sizes = squid_core::fs::measure_all(&targets, cancel, |index, completed, info| {
let emit_line = {
let mut guard = meter
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
guard.0 += info.files;
guard.1 += info.on_disk().as_u64();
if completed as u64 == targets.len() as u64
|| guard.2.elapsed() >= std::time::Duration::from_millis(90)
{
guard.2 = std::time::Instant::now();
Some((guard.0, guard.1))
} else {
None
}
};
if let Some((files, bytes)) = emit_line {
progress.publish(squid_core::progress::Event::Metered {
files,
bytes: Bytes(bytes),
});
}
progress.tick(
index as u64 + 1,
completed as u64,
Some(targets.len() as u64),
targets.get(index).map(|(path, _)| path.clone()),
);
@ -564,6 +668,15 @@ fn measure(report: &mut ScanReport, progress: &Progress, cancel: &CancelToken) {
for (item, info) in report.items.iter_mut().zip(sizes) {
item.size = info.logical;
item.allocated = info.allocated;
item.file_count = info.files;
item.last_write_secs = if info.newest_write == 0 {
None
} else {
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |since| since.as_secs());
Some(now.saturating_sub(info.newest_write))
};
if info.unreadable > 0 {
let suffix = format!("{} entries unreadable", info.unreadable);
item.note = Some(match item.note.take() {

View File

@ -248,9 +248,9 @@ fn measure(
.iter()
.map(|item| (item.path.clone(), item.kind))
.collect();
let sizes = squid_core::fs::measure_all(&targets, cancel, |index, _info| {
let sizes = squid_core::fs::measure_all(&targets, cancel, |index, completed, _info| {
progress.tick(
index as u64 + 1,
completed as u64,
Some(targets.len() as u64),
targets.get(index).map(|(path, _)| path.clone()),
);

View File

@ -266,21 +266,104 @@ mod windows {
list: &str,
value_name: &str,
enabled: bool,
) -> Result<(), String> {
) -> std::io::Result<()> {
let hive = RegKey::predef(if machine {
HKEY_LOCAL_MACHINE
} else {
HKEY_CURRENT_USER
});
let (key, _) = hive
.create_subkey(format!(r"{base}\Explorer\StartupApproved\{list}"))
.map_err(registry_error)?;
// Minimal rights only: several security suites (and locked-down
// profiles) deny KEY_ALL_ACCESS-style opens on the startup trees even
// for the key's own owner, which used to make every toggle fail.
let (key, _) = hive.create_subkey_with_flags(
format!(r"{base}\Explorer\StartupApproved\{list}"),
KEY_READ | KEY_WRITE,
)?;
let marker = winreg::RegValue {
bytes: approved_marker(enabled),
vtype: RegType::REG_BINARY,
};
key.set_raw_value(value_name, &marker)
.map_err(registry_error)
}
/// Task Manager's marker rendered for `reg.exe` (12 bytes, hex).
fn approved_marker_hex(enabled: bool) -> String {
let mut hex = String::from(if enabled { "02" } else { "03" });
hex.push_str(&"0".repeat(22));
hex
}
/// Flip an approval marker, escalating through a one-shot UAC prompt when
/// the direct write is denied (machine-scope keys, protected hives). The
/// result is verified against the registry itself, so a cancelled prompt
/// reports failure instead of a silently dead switch.
fn flip_approved(
machine: bool,
base: &str,
list: &str,
value_name: &str,
enabled: bool,
) -> Result<(), String> {
if let Err(why) = write_approved(machine, base, list, value_name, enabled) {
if why.kind() != std::io::ErrorKind::PermissionDenied {
return Err(registry_error(why));
}
let hive_label = if machine { "HKLM" } else { "HKCU" };
run_elevated(
"reg.exe",
&[
"add".to_string(),
format!(r"{hive_label}\{base}\Explorer\StartupApproved\{list}"),
"/v".to_string(),
value_name.to_string(),
"/t".to_string(),
"REG_BINARY".to_string(),
"/d".to_string(),
approved_marker_hex(enabled),
"/f".to_string(),
],
)?;
let hive = RegKey::predef(if machine {
HKEY_LOCAL_MACHINE
} else {
HKEY_CURRENT_USER
});
if approved_enabled(&hive, base, list, value_name) != enabled {
return Err("提权写入后状态仍未改变".to_string());
}
}
Ok(())
}
/// Single-quote one argument for a PowerShell -ArgumentList list.
fn quote_ps(value: &str) -> String {
format!("'{}'", value.replace('\'', "''"))
}
/// Run `program args…` elevated through `Start-Process -Verb RunAs`.
/// PowerShell's own exit code reports a cancelled or refused prompt.
fn run_elevated(program: &str, args: &[String]) -> Result<(), String> {
use std::os::windows::process::CommandExt;
let arglist = args
.iter()
.map(|arg| quote_ps(arg))
.collect::<Vec<_>>()
.join(",");
let script = format!(
"$ErrorActionPreference='Stop'; Start-Process -FilePath {} -ArgumentList {} -Verb RunAs -WindowStyle Hidden -Wait",
quote_ps(program),
arglist
);
let status = std::process::Command::new("powershell.exe")
.args(["-NoProfile", "-NonInteractive", "-Command", &script])
.creation_flags(0x0800_0000)
.status()
.map_err(|error| format!("无法启动提权助手:{error}"))?;
if status.success() {
Ok(())
} else {
Err("管理员授权被取消,未做修改".to_string())
}
}
fn display_name(command: &str) -> String {
@ -1455,7 +1538,7 @@ mod windows {
} else {
name.to_string()
};
write_approved(machine, &base, list, &marker, enabled)
flip_approved(machine, &base, list, &marker, enabled)
}
"folder" => {
let file = Path::new(rest)
@ -1463,7 +1546,7 @@ mod windows {
.map(|n| n.to_string_lossy().to_string())
.ok_or_else(|| "启动文件夹项目路径无效".to_string())?;
let machine = rest.contains("ProgramData");
write_approved(machine, CURRENT_VERSION, "StartupFolder", &file, enabled)
flip_approved(machine, CURRENT_VERSION, "StartupFolder", &file, enabled)
}
"task" => {
use std::os::windows::process::CommandExt;
@ -1478,23 +1561,79 @@ mod windows {
.output()
.map_err(|error| format!("无法调用 schtasks:{error}"))?;
if output.status.success() {
Ok(())
} else {
Err(format!(
return Ok(());
}
let stderr = String::from_utf8_lossy(&output.stderr).to_lowercase();
// schtasks reports "task not ready", missing tasks, etc. —
// only a plain access denial justifies a UAC round-trip.
let denied = stderr.contains("access is denied")
|| stderr.contains("access denied")
|| stderr.contains("拒绝访问");
if !denied {
return Err(format!(
"计划任务修改失败:{}",
String::from_utf8_lossy(&output.stderr).trim()
))
));
}
run_elevated(
"schtasks.exe",
&[
"/Change".to_string(),
"/TN".to_string(),
rest.to_string(),
if enabled { "/Enable" } else { "/Disable" }.to_string(),
],
)?;
Ok(())
}
"svc" => {
// 开 = Automatic(2),关 = Manual(3):保留按需启动能力,
// 与管家的“禁止开机自启”语义一致;HKLM 写入需要管理员。
let key = RegKey::predef(HKEY_LOCAL_MACHINE)
.open_subkey_with_flags(format!(r"{SERVICES_KEY}\{rest}"), KEY_READ | KEY_WRITE)
.map_err(registry_error)?;
key.set_value("Start", &(if enabled { 2u32 } else { 3u32 }))
.map_err(registry_error)?;
let _ = service_control(rest, if enabled { "auto" } else { "demand" });
let start = if enabled { 2u32 } else { 3u32 };
let key_path = format!(r"{SERVICES_KEY}\{rest}");
let direct = (|| -> std::io::Result<()> {
let key = RegKey::predef(HKEY_LOCAL_MACHINE)
.open_subkey_with_flags(&key_path, KEY_READ | KEY_WRITE)?;
key.set_value("Start", &start)
})();
if let Err(why) = direct {
if why.kind() != std::io::ErrorKind::PermissionDenied {
return Err(registry_error(why));
}
run_elevated(
"reg.exe",
&[
"add".to_string(),
format!(r"HKLM\{key_path}"),
"/v".to_string(),
"Start".to_string(),
"/t".to_string(),
"REG_DWORD".to_string(),
"/d".to_string(),
start.to_string(),
"/f".to_string(),
],
)?;
let live = RegKey::predef(HKEY_LOCAL_MACHINE)
.open_subkey_with_flags(&key_path, KEY_READ)
.map(|key| key.get_value::<u32, _>("Start").ok())
.ok()
.flatten();
if live != Some(start) {
return Err("提权写入后服务状态仍未改变".to_string());
}
}
if service_control(rest, if enabled { "auto" } else { "demand" }).is_err() {
let _ = run_elevated(
"sc.exe",
&[
"config".to_string(),
rest.to_string(),
"start=".to_string(),
if enabled { "auto" } else { "demand" }.to_string(),
],
);
}
Ok(())
}
_ => Err("未知的启动项来源".to_string()),
@ -1913,9 +2052,56 @@ mod windows {
#[cfg(test)]
mod tests {
use super::{
clean_module_path, exe_from_command, friendly_program_name, has_cjk,
is_placeholder_label, module_folder_name, parse_csv_line, task_settings_enabled,
approved_enabled, clean_module_path, exe_from_command, friendly_program_name, has_cjk,
is_placeholder_label, module_folder_name, parse_csv_line, split_run_path,
task_settings_enabled, write_approved, CURRENT_VERSION,
};
use winreg::RegKey;
#[test]
fn toggle_round_trips_through_the_approved_marker() {
// The exact pair the UI toggle relies on: write_approved stores a
// marker, the rescan reads it back. If these ever drift, every
// startup switch silently snaps back — the "button is dead" bug.
let list = format!("squidTest{}", std::process::id());
let hive = RegKey::predef(winreg::enums::HKEY_CURRENT_USER);
let key_path = format!(r"{CURRENT_VERSION}\Explorer\StartupApproved\{list}");
for name in ["squid-off", "squid-on"] {
let want = name.ends_with("on");
if let Err(why) = write_approved(false, CURRENT_VERSION, &list, name, want) {
// Sandboxed CI runners deny registry writes; the marker
// round-trip cannot be proven here, so say so instead of
// failing a correct build.
eprintln!("skipping marker round-trip: registry write denied ({why})");
return;
}
assert_eq!(
approved_enabled(&hive, CURRENT_VERSION, &list, name),
want,
"{name} must read back as written"
);
}
let _ = hive.delete_subkey_all(&key_path);
}
#[test]
fn run_path_split_round_trips_hive_and_list() {
// set_startup_enabled re-derives (machine, base, list) from the
// id scan produced; a mismatch writes the marker to the wrong key
// and the rescan then shows the old state.
let wow_run = r"Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Run".to_string();
let (machine, base, list, prefix32) = split_run_path("HKLM", &wow_run);
assert!(machine);
assert_eq!(list, "Run");
assert!(prefix32);
assert!(base.contains("WOW6432Node"));
let (machine, base, list, prefix32) =
split_run_path("HKCU", &format!(r"{CURRENT_VERSION}\RunOnce"));
assert!(!machine);
assert_eq!(list, "RunOnce");
assert!(!prefix32);
assert_eq!(base, CURRENT_VERSION);
}
#[test]
fn command_paths_survive_quotes_and_arguments() {

View File

@ -889,6 +889,7 @@ impl App {
};
panel.buckets.insert(category, (total, count));
}
Event::Metered { .. } => {}
Event::Deleted { path, freed } => {
self.push_log(format!(
"removed {} ({})",

View File

@ -1,6 +1,31 @@
Squid 0.1.10 更新说明
新增
- 空间清理全面对齐专业清理工具的扫描体验(借鉴 Mole):
· 扫描时实时显示「已统计 12.8 万个文件 · 38.2 GB」滚动计数,进度条在真正
完成前最多走到 99%,不再出现「满了但还在转」的错觉;
· 各分类不再干等:哪个分类先算完就先在扫描界面出现(项数 + 大小);
· 清理点与文件行显示「12 个月未使用」休眠标签(超过 90 天没再写入的绿色
标注),配合大小一起帮你决定删不删;
· node_modules 等项目产物新增「可删依据」面板:锁文件 / 安装记录 / 有无
手工修改 / Git 状态 / 目录年龄逐条列出,被手改过的目录会红色警示;
· 低风险清理(≤40 项、不含升级包、复核全部通过)不再弹窗,底部绿色
确认条一步完成(Esc 取消);含升级包或大批量仍走确认对话框,对话框内
新增「刚刚逐路径复核过 N 项」折叠面板,展示删除前的最后一轮锁 / 白名单
/ 应用运行 / 路径消失复核结果;
· 清理完成后新增「有 N 项本次未处理」分组页:按原因(应用正在运行 /
需要管理员 / 已消失 / 白名单 / 受保护)归类,每组给下一步操作按钮;
· 结果列表可一键「导出清单」,生成 Markdown 文件(含每一项路径、大小、
依据与受保护项),方便留档或反馈。
- 存储空间页新增「隐藏的吃空间大户」:Windows 更新缓存、休眠文件、页面文件、
WinSxS 组件库、手机备份、90 天前的下载,逐项给出大小与下一步(查看 /
复制释放命令);同页文件夹测量结果缓存 10 分钟,秒开时标注「缓存数据 ·
上次测量 X 分钟前」并可一键重新测量,删除文件后缓存自动作废。
- 微信 / QQ 聊天文件、浏览器离线应用数据(IndexedDB)、搜狗词库等「看起来像
缓存、实际是你的文件」的目录,现在会以待解锁行出现在扫描结果里并写明原因,
引擎在删除层也强制拒删。
- 设置 → 受保护的位置新增「消费审计」:每条白名单规则标注最近扫描是否命中,
从未命中的过期规则一眼可见。
- 清理新增「升级安装包」分类:找出应用升级完成后留在 AppData 里的安装包
(微信、企业微信、WPS、网易邮箱等已知应用精确规则 + AppData 启发式扫描)。
只匹配安装包形态(exe/msi/zip/7z 等)且放置超过 7 天的文件,微信运行库组件
@ -21,6 +46,10 @@ Squid 0.1.10 更新说明
开着时 Squid 全家 CPU 占用接近 0%。
修复
- 权限管理:修复开机启动项开关点了没反应 / 立刻弹回的问题——所有启动项
(当前用户、所有用户、32 位、启动文件夹、服务、计划任务)统一改用最小
注册表权限写入,遇到「拒绝访问」自动发起一次系统管理员授权(UAC)后重试
并回读核实;开关失败时现在有红色气泡提示原因(此前只在页面顶部一闪而过)。
- 权限管理:开机启动项每个子行不再重复显示软件图标(图标只在软件分组标题
出现一次,子行文字与标题对齐)。
- 空间清理:修复扫描后分类卡片与复选框全部不可点击的问题(勾选状态没有

View File

@ -1,2 +1,2 @@
046b0e2ad7e3a9dd8558d7ff673d5bd8b4d78c8337055847f7a789003cc31ef5 Squid-Setup-0.1.10-win-x64.exe
587c70cc7bbbd48f29ee659baf86e30de16c3c13d9aa02c9c0b188f615d0027d Squid-0.1.10-portable-win-x64.zip
1ddd17bd66a982cfdfbf15e187c213ef005619b7f6fee16ffc72dce47f105705 Squid-Setup-0.1.10-win-x64.exe
8e814c57ebb7fb6f887abfd2fd2290ad75ba0b8dc7e9694ff747fb530d19e59e Squid-0.1.10-portable-win-x64.zip

File diff suppressed because one or more lines are too long

View File

@ -35,6 +35,11 @@ pub struct AppState {
/// Last light snapshot, so the widget window and the main window polling
/// a beat apart share one refresh instead of paying for two.
snapshot_cache: Mutex<Option<(Instant, squid_stats::SystemSnapshot)>>,
/// Mole-style size cache (A⑥): explored storage trees answered from
/// memory until a delete run bumps the epoch and invalidates them.
/// Stamp is wall-clock so the age survives nicely for UI copy.
storage_cache: Mutex<HashMap<String, (u64, std::time::SystemTime, analyze::Node)>>,
clean_epoch: std::sync::atomic::AtomicU64,
}
impl AppState {
@ -44,6 +49,16 @@ impl AppState {
.map_err(|_| "The application state is unavailable; restart Squid.".to_string())
}
fn epoch(&self) -> u64 {
self.clean_epoch.load(std::sync::atomic::Ordering::Relaxed)
}
/// Any successful delete invalidates cached storage sizes (Mole bumps its
/// cache schema whenever deletion semantics change what totals mean).
fn invalidate_storage_cache(&self) {
self.clean_epoch.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
}
fn begin(&self, job_id: &str) -> Result<CancelToken, String> {
if job_id.trim().is_empty() {
return Err("A job identifier is required.".into());
@ -193,6 +208,17 @@ fn emit_progress(app: &AppHandle, job_id: &str, kind: &str, event: Event) {
subject: None,
freed: None,
},
Event::Metered { files, bytes } => ProgressView {
job_id: job_id.into(),
kind: kind.into(),
event: "metered".into(),
phase: None,
detail: None,
done: Some(files),
total: Some(bytes.as_u64()),
subject: None,
freed: None,
},
Event::Done(_) => return,
};
let _ = app.emit("squid://progress", payload);
@ -213,6 +239,9 @@ pub struct CleanupItemView {
selected: bool,
lock: Option<LockReason>,
note: Option<String>,
last_write_secs: Option<u64>,
file_count: u64,
evidence: Vec<String>,
}
impl From<&CleanupItem> for CleanupItemView {
@ -230,6 +259,9 @@ impl From<&CleanupItem> for CleanupItemView {
selected: item.selected,
lock: item.lock,
note: item.note.clone(),
last_write_secs: item.last_write_secs,
file_count: item.file_count,
evidence: item.evidence.clone(),
}
}
}
@ -508,6 +540,7 @@ pub async fn cleanup_delete(
if let Ok(mut scans) = app.state::<AppState>().scans.lock() {
scans.remove(&scan_id);
}
app.state::<AppState>().invalidate_storage_cache();
Ok(DeleteResultView::from_outcome(outcome))
}
@ -591,6 +624,7 @@ pub async fn purge_delete(
if let Ok(mut scans) = app.state::<AppState>().scans.lock() {
scans.remove(&scan_id);
}
app.state::<AppState>().invalidate_storage_cache();
Ok(DeleteResultView::from_outcome(outcome))
}
@ -759,9 +793,24 @@ pub async fn app_uninstall(
if let Ok(mut plans) = app.state::<AppState>().plans.lock() {
plans.remove(&plan_id);
}
app.state::<AppState>().invalidate_storage_cache();
Ok(DeleteResultView::from_outcome(outcome))
}
/// What `storage_explore` answers: the tree plus how fresh it is (A⑥).
/// `cached` = served from the in-memory size cache; `measuredAtMs` = age of
/// the measurement so the page can say "12 分钟前" honestly. `Node` itself
/// serializes camelCase, same as before for the frontend contract.
#[derive(Clone, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ExploreView {
node: Node,
cached: bool,
measured_at_ms: Option<u64>,
}
const STORAGE_TTL: std::time::Duration = std::time::Duration::from_secs(600);
#[tauri::command]
pub async fn storage_explore(
app: AppHandle,
@ -769,7 +818,8 @@ pub async fn storage_explore(
path: Option<String>,
depth: Option<usize>,
top: Option<usize>,
) -> Result<Node, String> {
force: Option<bool>,
) -> Result<ExploreView, String> {
let token = app.state::<AppState>().begin(&job_id)?;
let progress = Progress::new();
let reporter =
@ -783,20 +833,114 @@ pub async fn storage_explore(
reporter.finish();
return Err(format!("{} is not a folder.", root.display()));
}
let depth = depth.unwrap_or(1).clamp(1, 3);
let top = top.unwrap_or(16);
let state = app.state::<AppState>();
let key = format!("{}|{depth}|{top}", root.to_string_lossy().to_lowercase());
let epoch = state.epoch();
if !force.unwrap_or(false) {
if let Ok(cache) = state.storage_cache.lock() {
if let Some((cached_epoch, at, node)) = cache.get(&key) {
let age = std::time::SystemTime::now()
.duration_since(*at)
.unwrap_or_default();
let fresh = epoch == *cached_epoch && age < STORAGE_TTL;
if fresh {
app.state::<AppState>().finish(&job_id);
reporter.finish();
return Ok(ExploreView {
node: node.clone(),
cached: true,
measured_at_ms: Some(u64::try_from(age.as_millis()).unwrap_or(u64::MAX)),
});
}
}
}
}
let task = tauri::async_runtime::spawn_blocking(move || {
analyze::explore(
&root,
depth.unwrap_or(1).clamp(1, 3),
top.unwrap_or(16),
&token,
&progress,
)
analyze::explore(&root, depth, top, &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())
let node = task.map_err(|error| error.to_string())?;
if let Ok(mut cache) = state.storage_cache.lock() {
// Tiny memory cap: the epoch clears everything after a delete run.
if cache.len() > 48 {
cache.clear();
}
cache.insert(key, (epoch, std::time::SystemTime::now(), node.clone()));
}
Ok(ExploreView {
node,
cached: false,
measured_at_ms: Some(0),
})
}
#[derive(Clone, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct InsightView {
id: String,
title: String,
path: String,
size: u64,
action: String,
command: Option<String>,
hint: String,
}
/// Hidden-space insights for the storage page's curated section (A⑤).
#[tauri::command]
pub async fn storage_insights() -> Result<Vec<InsightView>, String> {
let rows = tauri::async_runtime::spawn_blocking(squid_engine::insights::collect)
.await
.map_err(|error| format!("Insight scan failed: {error}"))?;
Ok(rows
.into_iter()
.map(|row| InsightView {
id: row.id,
title: row.title,
path: row.path,
size: row.size,
action: row.action,
command: row.command,
hint: row.hint,
})
.collect())
}
/// Mole-style last-second re-check surfaced before deletion (B1).
#[tauri::command]
pub async fn cleanup_preflight(
app: AppHandle,
scan_id: String,
selected: Vec<usize>,
) -> Result<serde_json::Value, String> {
let 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())?;
let view = tauri::async_runtime::spawn_blocking(move || {
let engine = Engine::new();
let preflight = engine.preflight(&report, &selected);
serde_json::json!({
"checked": preflight.checked,
"blocked": preflight
.blocked
.into_iter()
.map(|(path, reason)| serde_json::json!({ "path": path, "reason": reason }))
.collect::<Vec<_>>(),
})
})
.await
.map_err(|error| error.to_string())?;
Ok(view)
}
#[tauri::command]
@ -864,6 +1008,34 @@ pub fn stop_process(app: AppHandle, process: ProcessSample) -> Result<(), String
sampler.stop(&process).map_err(|error| error.to_string())
}
/// Write a UTF-8 text file (B5 clean-list export; the UI picked the path
/// through the save dialog, so this is a plain, bounded write).
#[tauri::command]
pub async fn write_text_file(path: String, contents: String) -> Result<(), String> {
tauri::async_runtime::spawn_blocking(move || {
let target = paths::expand(&path);
std::fs::write(&target, contents.as_bytes())
.map_err(|error| format!("{}: {error}", target.display()))
})
.await
.map_err(|error| error.to_string())?
}
/// B2: which protection patterns actually hit something on this machine.
#[tauri::command]
pub async fn whitelist_audit() -> Result<serde_json::Value, String> {
let rows: Vec<serde_json::Value> = tauri::async_runtime::spawn_blocking(|| {
Engine::new()
.audit_whitelist()
.into_iter()
.map(|(pattern, live)| serde_json::json!({ "pattern": pattern, "live": live }))
.collect::<Vec<_>>()
})
.await
.map_err(|error| error.to_string())?;
Ok(serde_json::Value::Array(rows))
}
#[tauri::command]
pub fn history_list(limit: Option<usize>) -> Vec<Session> {
ledger::load_sessions(limit.unwrap_or(60).clamp(1, 500))

View File

@ -122,12 +122,15 @@ pub fn run() {
app::cancel_job,
app::cleanup_scan,
app::cleanup_delete,
app::cleanup_preflight,
app::purge_scan,
app::purge_delete,
app::apps_scan,
app::app_plan,
app::app_uninstall,
app::storage_explore,
app::storage_insights,
app::write_text_file,
app::storage_largest_files,
app::system_snapshot,
app::stop_process,
@ -136,6 +139,7 @@ pub fn run() {
app::settings_save,
app::whitelist_add,
app::whitelist_remove,
app::whitelist_audit,
app::reveal_path,
app::open_trash,
permissions::permission_status,

View File

@ -274,11 +274,18 @@ export function ProgressCard({
title,
onCancel,
compact = false,
liveLine,
capAt99 = false,
}: {
progress: JobProgress | null;
title: string;
onCancel?: () => void;
compact?: boolean;
/** "已统计 128,431 文件 · 38.2 GB" streamed side-band (A①). */
liveLine?: string | null;
/** Scans hold the bar at 99% until the final number lands — a full bar
* that is still working reads as a lie (Mole's cap discipline). */
capAt99?: boolean;
}) {
const { t, lang } = useI18n();
const phase = useMemo(() => {
@ -301,7 +308,9 @@ export function ProgressCard({
const denominator = progress?.total ?? 0;
const done = progress?.done ?? 0;
const ratio =
denominator > 0 ? Math.min(100, Math.max(0, (done / denominator) * 100)) : null;
denominator > 0
? Math.min(capAt99 ? 99 : 100, Math.max(0, (done / denominator) * 100))
: null;
const detail = progress?.detail || progress?.subject || "";
return (
@ -330,6 +339,11 @@ export function ProgressCard({
>
<span style={{ width: ratio === null ? undefined : `${ratio}%` }} />
</div>
{liveLine ? (
<div className="progress-live" role="status">
{liveLine}
</div>
) : null}
<div className="progress-detail" title={detail}>
{detail || t("Working safely in the background…", "正在后台安全处理…")}
</div>

View File

@ -1,6 +1,7 @@
import { useCallback, useEffect, useState } from "react";
import { api } from "../lib/api";
import { isCancelled, messageFrom } from "../lib/format";
import { useToast } from "../components/ui";
import type { ManageView, PopupWindowItem } from "../types";
export type PermissionsTab = "startup" | "extensions" | "popup";
@ -36,6 +37,7 @@ export function usePermissionsWorkspace(active: boolean): PermissionsWorkspace {
const [error, setError] = useState<string | null>(null);
const [closedTotal, setClosedTotal] = useState(0);
const [recentClosed, setRecentClosed] = useState<{ process: string; title: string }[]>([]);
const { push } = useToast();
const scan = useCallback(async () => {
setScanning(true);
@ -101,12 +103,16 @@ export function usePermissionsWorkspace(active: boolean): PermissionsWorkspace {
await api.startupSetEnabled(id, enabled);
await scan();
} catch (reason) {
setError(messageFrom(reason));
const why = messageFrom(reason);
setError(why);
// The row snaps back without this; a toast right where the user is
// looking explains *why* (cancelled UAC prompt, protected key, …).
push(why, "danger");
} finally {
setBusyId(null);
}
},
[scan],
[push, scan],
);
const toggleExtension = useCallback(

View File

@ -35,6 +35,10 @@ export interface ScanWorkspace {
result: ScanResult | null;
selected: Set<number>;
progress: JobProgress | null;
/** Live measurement counters streamed during a scan (A①). */
stats: { files: number; bytes: number } | null;
/** Per-category totals streamed in as each bucket finishes (A②). */
buckets: Partial<Record<Category, { total: number; count: number }>>;
scanning: boolean;
deleting: boolean;
error: string | null;
@ -73,6 +77,10 @@ export function useScanWorkspace(
const [result, setResult] = useState<ScanResult | null>(null);
const [selected, setSelected] = useState<Set<number>>(new Set());
const [progress, setProgress] = useState<JobProgress | null>(null);
const [stats, setStats] = useState<{ files: number; bytes: number } | null>(null);
const [buckets, setBuckets] = useState<
Partial<Record<Category, { total: number; count: number }>>
>({});
const [scanning, setScanning] = useState(false);
const [deleting, setDeleting] = useState(false);
const [error, setError] = useState<string | null>(null);
@ -94,7 +102,28 @@ export function useScanWorkspace(
setError(null);
setSummary(null);
setProgress(null);
const stop = await subscribeJobProgress(id, setProgress);
setStats(null);
setBuckets({});
// Streamed side-band (A①②): `metered` carries running counters (kept
// out of `progress`, whose done/total mean "units done / units total"),
// `bucket` one finished category at a time (detail = "cat:count:total").
const stop = await subscribeJobProgress(id, (event) => {
if (event.event === "metered" && event.done !== null && event.total !== null) {
setStats({ files: event.done, bytes: event.total });
return;
}
setProgress(event);
if (event.event === "bucket" && event.detail) {
const [category, count, total] = event.detail.split(":");
setBuckets((current) => ({
...current,
[category as Category]: {
count: Number(count) || 0,
total: Number(total) || 0,
},
}));
}
});
try {
const next =
kind === "cleanup"
@ -115,6 +144,7 @@ export function useScanWorkspace(
if (activeJob.current === id) {
setScanning(false);
setProgress(null);
setStats(null);
setCurrentJob(null);
}
}
@ -276,6 +306,8 @@ export function useScanWorkspace(
result,
selected,
progress,
stats,
buckets,
scanning,
deleting,
error,

View File

@ -1,7 +1,7 @@
import { useCallback, useRef, useState } from "react";
import { api, subscribeJobProgress } from "../lib/api";
import { isCancelled, messageFrom } from "../lib/format";
import type { JobProgress, LargestFile, StorageNode } from "../types";
import type { ExploreResult, JobProgress, LargestFile, StorageNode } from "../types";
function jobId(): string {
return crypto.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`;
@ -9,12 +9,15 @@ function jobId(): string {
export interface StorageWorkspace {
node: StorageNode | null;
/** Freshness of the current node (A⑥ size cache). */
cached: boolean;
measuredAtMs: number | null;
files: LargestFile[];
progress: JobProgress | null;
exploring: boolean;
scanningFiles: boolean;
error: string | null;
explore: (path?: string | null) => Promise<void>;
explore: (path?: string | null, force?: boolean) => Promise<void>;
largestFiles: (path: string) => Promise<void>;
cancel: () => Promise<void>;
clearError: () => void;
@ -23,6 +26,8 @@ export interface StorageWorkspace {
export function useStorageWorkspace(): StorageWorkspace {
const [node, setNode] = useState<StorageNode | null>(null);
const [cached, setCached] = useState(false);
const [measuredAtMs, setMeasuredAtMs] = useState<number | null>(null);
const [files, setFiles] = useState<LargestFile[]>([]);
const [progress, setProgress] = useState<JobProgress | null>(null);
const [exploring, setExploring] = useState(false);
@ -30,7 +35,7 @@ export function useStorageWorkspace(): StorageWorkspace {
const [error, setError] = useState<string | null>(null);
const activeJob = useRef<string | null>(null);
const explore = useCallback(async (path?: string | null) => {
const explore = useCallback(async (path?: string | null, force = false) => {
if (exploring || scanningFiles) return;
const id = jobId();
activeJob.current = id;
@ -40,9 +45,11 @@ export function useStorageWorkspace(): StorageWorkspace {
setFiles([]);
const stop = await subscribeJobProgress(id, setProgress);
try {
const next = await api.storageExplore(id, path ?? null, 1, 16);
const next: ExploreResult = await api.storageExplore(id, path ?? null, 1, 16, force);
if (activeJob.current !== id) return;
setNode(next);
setNode(next.node);
setCached(next.cached);
setMeasuredAtMs(next.measuredAtMs);
} catch (reason) {
if (!isCancelled(reason)) setError(messageFrom(reason));
} finally {
@ -89,6 +96,8 @@ export function useStorageWorkspace(): StorageWorkspace {
return {
node,
cached,
measuredAtMs,
files,
progress,
exploring,

View File

@ -5,6 +5,7 @@ import type {
Bootstrap,
DeleteMode,
DeleteResult,
ExploreResult,
HistorySession,
JobProgress,
LargestFile,
@ -14,9 +15,10 @@ import type {
PlanResult,
PopupClosedEvent,
PopupWindowItem,
PreflightResult,
ScanResult,
SettingsView,
StorageNode,
SpaceInsight,
SystemSnapshot,
UndoResult,
UpdateCheckResult,
@ -52,6 +54,8 @@ export const api = {
}),
cleanupDelete: (jobId: string, scanId: string, selected: number[], mode: DeleteMode) =>
invoke<DeleteResult>("cleanup_delete", { jobId, scanId, selected, mode }),
cleanupPreflight: (scanId: string, selected: number[]) =>
invoke<PreflightResult>("cleanup_preflight", { scanId, selected }),
purgeScan: (jobId: string, roots: string[] = [], minAgeDays: number | null = null, force = false) =>
invoke<ScanResult>("purge_scan", { jobId, roots, minAgeDays, force }),
purgeDelete: (jobId: string, scanId: string, selected: number[], mode: DeleteMode) =>
@ -60,8 +64,9 @@ export const api = {
appPlan: (jobId: string, appKey: string) => invoke<PlanResult>("app_plan", { jobId, appKey }),
appUninstall: (jobId: string, planId: string, selected: number[], mode: DeleteMode) =>
invoke<DeleteResult>("app_uninstall", { jobId, planId, selected, mode }),
storageExplore: (jobId: string, path?: string | null, depth = 1, top = 16) =>
invoke<StorageNode>("storage_explore", { jobId, path, depth, top }),
storageExplore: (jobId: string, path?: string | null, depth = 1, top = 16, force = false) =>
invoke<ExploreResult>("storage_explore", { jobId, path, depth, top, force }),
storageInsights: () => invoke<SpaceInsight[]>("storage_insights"),
storageLargestFiles: (jobId: string, path: string, limit = 40) =>
invoke<LargestFile[]>("storage_largest_files", { jobId, path, limit }),
systemSnapshot: (full = false) => invoke<SystemSnapshot>("system_snapshot", { full }),
@ -72,6 +77,9 @@ export const api = {
settingsSave: (patch: SettingsPatch) => invoke<SettingsView>("settings_save", { patch }),
whitelistAdd: (path: string) => invoke<SettingsView>("whitelist_add", { path }),
whitelistRemove: (pattern: string) => invoke<SettingsView>("whitelist_remove", { pattern }),
whitelistAudit: () => invoke<{ pattern: string; live: boolean }[]>("whitelist_audit"),
writeTextFile: (path: string, contents: string) =>
invoke<void>("write_text_file", { path, contents }),
revealPath: (path: string) => invoke<void>("reveal_path", { path }),
openTrash: () => invoke<void>("open_trash"),
permissionStatus: () => invoke<PermissionStatus>("permission_status"),

View File

@ -98,3 +98,45 @@ export function isCancelled(error: unknown): boolean {
const text = messageFrom(error).toLowerCase();
return text.includes("cancel") || text.includes("取消");
}
/* "最后写入 3 个月前" / "written into 3 months ago" — the Mole decision
* aid: size alone is not actionable, dormancy is. */
export function ageLabel(secs: number, lang: "zh" | "en"): string {
const days = Math.floor(secs / 86_400);
if (lang === "zh") {
if (days < 1) return "今天有改动";
if (days < 30) return `${days} 天未修改`;
if (days < 365) return `${Math.floor(days / 30)} 个月未修改`;
return `${(days / 365).toFixed(days < 730 ? 1 : 0)} 年未修改`;
}
if (days < 1) return "written today";
if (days < 30) return `${days} days untouched`;
if (days < 365) return `${Math.floor(days / 30)} months untouched`;
return `${(days / 365).toFixed(days < 730 ? 1 : 0)} years untouched`;
}
/* "12 分钟前" for cache freshness lines. */
export function agoLabel(ms: number, lang: "zh" | "en"): string {
const mins = Math.floor(ms / 60_000);
if (lang === "zh") {
if (mins < 1) return "刚刚";
if (mins < 60) return `${mins} 分钟前`;
return `${Math.floor(mins / 60)} 小时前`;
}
if (mins < 1) return "just now";
if (mins < 60) return `${mins} min ago`;
return `${Math.floor(mins / 60)} h ago`;
}
/* Throttled "128,431 文件 · 38.2 GB" live scan counter (A①). */
export function countLabel(files: number, bytes: number, lang: "zh" | "en"): string {
const f = formatThousands(files);
const b = formatBytes(bytes);
return lang === "zh" ? `已统计 ${f} 个文件 · ${b}` : `${f} files · ${b} measured`;
}
function formatThousands(value: number): string {
return Math.round(value)
.toString()
.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

View File

@ -58,6 +58,29 @@ export function SettingsPage({
const [error, setError] = useState<string | null>(null);
const [permission, setPermission] = useState<PermissionStatus | null>(null);
const [checkingPermission, setCheckingPermission] = useState(false);
// B2 (Mole #458): whitelist entries are only as good as their last hit.
// The audit answers "did this pattern ever protect something real?"
const [audit, setAudit] = useState<Map<string, boolean> | null>(null);
const [auditing, setAuditing] = useState(false);
const runAudit = useCallback(async () => {
setAuditing(true);
try {
const rows = await api.whitelistAudit();
setAudit(new Map(rows.map((row) => [row.pattern, row.live])));
} catch {
setAudit(null);
} finally {
setAuditing(false);
}
}, []);
useEffect(() => {
if (settings.whitelist.length > 0 && audit === null && !auditing) {
void runAudit();
}
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [settings.whitelist.length]);
const checkPermissions = useCallback(async () => {
setCheckingPermission(true);
@ -384,6 +407,30 @@ export function SettingsPage({
{t("Add", "添加")}
</Button>
</div>
{settings.whitelist.length > 0 ? (
<div className="whitelist-audit-bar">
<span>
{audit === null
? t(
"Checking whether each pattern still matches anything…",
"正在核对每条规则是否还命中过内容…",
)
: t(
`Consumption audit: ${[...audit.values()].filter(Boolean).length} of ${audit.size} pattern(s) matched known cache locations`,
`消费审计:${audit.size} 条规则中 ${[...audit.values()].filter(Boolean).length} 条命中过已知缓存位置`,
)}
</span>
<Button
variant="ghost"
size="sm"
icon={<RefreshCw size={13} className={auditing ? "spin" : undefined} />}
onClick={() => void runAudit()}
disabled={auditing}
>
{t("Re-check", "重新检查")}
</Button>
</div>
) : null}
<div className="whitelist-list">
{settings.whitelist.length === 0 ? (
<p className="settings-empty">
@ -396,6 +443,25 @@ export function SettingsPage({
<ShieldCheck size={15} />
</span>
<code title={pattern}>{shortPath(pattern, 88)}</code>
{audit ? (
<span
className={`whitelist-audit-chip ${
audit.get(pattern) ? "is-live" : "is-dead"
}`}
title={t(
audit.get(pattern)
? "This pattern matched paths squid knows about on the last scan"
: "This pattern has never matched anything — it may be stale",
audit.get(pattern)
? "最近扫描命中过这条规则保护的位置"
: "从未命中任何已知位置,规则可能已经过期",
)}
>
{audit.get(pattern)
? t("Recently matched", "最近命中")
: t("Never matched", "从未命中")}
</span>
) : null}
<button
className="row-reveal"
aria-label={t("Remove protection", "移除保护")}

View File

@ -10,11 +10,13 @@ import {
ArrowUpRight,
ChevronRight,
DownloadCloud,
FileText,
FolderOpen,
ScanSearch,
ShieldCheck,
Trash2,
} from "lucide-react";
import { open } from "@tauri-apps/plugin-dialog";
import { open, save } from "@tauri-apps/plugin-dialog";
import {
useCallback,
useEffect,
@ -24,13 +26,20 @@ import {
} from "react";
import { useI18n } from "../i18n";
import { api } from "../lib/api";
import { formatBytes, formatCount, shortPath } from "../lib/format";
import {
ageLabel,
countLabel,
formatBytes,
formatCount,
shortPath,
} from "../lib/format";
import type {
Bootstrap,
Category,
CleanupItem,
DeleteMode,
DeleteResult,
PreflightResult,
} from "../types";
import type { ScanWorkspace } from "../hooks/useScanWorkspace";
import {
@ -100,6 +109,7 @@ const RULE_NAMES: Record<string, [string, string]> = {
"update-installers-known": ["Known app update packages", "已知应用的升级包"],
"update-installers-scan": ["Other update packages", "其他升级安装包"],
"purge-artifacts": ["Build artefacts", "项目构建产物"],
"user-assets": ["Your own files (locked)", "您的个人文件(受保护)"],
};
function ruleName(ruleId: string, lang: "zh" | "en"): string {
@ -140,6 +150,134 @@ type Cluster = {
selected: number;
};
/* A⑦: skipped items on the result page are grouped by *why* they were
* skipped, each group with the concrete next step — Mole's ledger reads as
* "here is what to do about it", not as a wall of paths. */
type SkipGroup = {
key: string;
title: [string, string];
hint: [string, string];
action?: "rescan";
};
function skipGroupOf(reason: string): SkipGroup {
const lower = reason.toLowerCase();
if (lower.includes("running") || lower.includes("占用")) {
return {
key: "running",
title: ["应用正在运行", "应用正在运行"],
hint: ["退出这些应用后重新扫描,即可再次选中。", "退出这些应用后重新扫描,即可再次选中。"],
action: "rescan",
};
}
if (lower.includes("admin") || lower.includes("管理员")) {
return {
key: "admin",
title: ["需要管理员权限", "需要管理员权限"],
hint: [
"以管理员身份重新启动 Squid 后再清理这批项目。",
"以管理员身份重新启动 Squid 后再清理这批项目。",
],
action: "rescan",
};
}
if (lower.includes("已不存在") || lower.includes("no longer") || lower.includes("missing")) {
return {
key: "gone",
title: ["扫描后已消失", "扫描后已消失"],
hint: ["这些路径在清理开始前就不在了,无需处理。", "这些路径在清理开始前就不在了,无需处理。"],
};
}
if (lower.includes("whitelist")) {
return {
key: "whitelist",
title: ["命中白名单", "命中白名单"],
hint: [
"在 设置 → 白名单 中移除对应规则后才会被清理。",
"在 设置 → 白名单 中移除对应规则后才会被清理。",
],
};
}
return {
key: "protected",
title: ["受安全策略保护", "受安全策略保护"],
hint: [
"这些目录看似缓存,实际可能存有您自己的文件,Squid 不会删除。",
"这些目录看似缓存,实际可能存有您自己的文件,Squid 不会删除。",
],
};
}
/* A③: a cluster is "dormant" when its newest member stopped changing more
* than 90 days ago — size plus dormancy is what makes a deletion call easy. */
const DORMANT_SECS = 90 * 24 * 3600;
function clusterDormancy(cluster: { entries: Entry[] }): number | null {
let oldest: number | null = null;
for (const entry of cluster.entries) {
const secs = entry.item.lastWriteSecs;
if (secs == null) continue;
if (oldest === null || secs > oldest) oldest = secs;
}
return oldest;
}
/* B3 evidence tokens → human lines. Unknown tokens render verbatim, so a
* future engine token still shows up instead of vanishing. */
function evidenceLines(
tokens: string[],
t: (en: string, zh: string) => string,
): { ok: boolean; text: string }[] {
const lines: { ok: boolean; text: string }[] = [];
for (const token of tokens) {
if (token.startsWith("lock:")) {
lines.push({
ok: true,
text: t(
`${token.slice(5)} present — the tree rebuilds with one command`,
`存在 ${token.slice(5)},一条命令即可完整重建`,
),
});
} else if (token.startsWith("record:")) {
lines.push({
ok: true,
text: t(
`${token.slice(7)} present — install record intact`,
`存在 ${token.slice(7)} 安装记录`,
),
});
} else if (token === "record-missing") {
lines.push({
ok: true,
text: t("No install record found — skipped the hand-edit check", "缺少安装记录,未做手改检查"),
});
} else if (token.startsWith("modified:")) {
const count = Number(token.slice(9)) || 0;
lines.push(
count === 0
? { ok: true, text: t("No file is newer than the install record (nobody hand-edited it)", "无文件晚于安装记录(没有被手工修改)") }
: { ok: false, text: t(`${count} files are newer than the install record — possible local patches`, `${count} 个文件晚于安装记录,可能被手工修改过`) },
);
} else if (token === "git:ignored") {
lines.push({ ok: true, text: t("Marked .gitignore by the project", "已被项目 .gitignore 忽略") });
} else if (token === "git:untracked") {
lines.push({ ok: true, text: t("Not tracked by git", "未被 Git 跟踪") });
} else if (token === "git:tracked") {
lines.push({ ok: false, text: t("Tracked by git — deleted only with --all", "被 Git 跟踪,需强制模式才删") });
} else if (token === "git:none") {
lines.push({ ok: true, text: t("No git repository around it", "附近没有 Git 仓库") });
} else if (token.startsWith("age:")) {
lines.push({
ok: true,
text: t(`Last change ${token.slice(4)} days ago`, `最后修改于 ${token.slice(4)} 天前`),
});
} else {
lines.push({ ok: true, text: token });
}
}
return lines;
}
/* A 清理点: one rule's worth of hits, aggregated like 电脑管家's sub-items.
* Tick = whole cluster; hover = 忽略 / 查看路径; body = expand to paths. */
function ClusterRow({
@ -159,6 +297,7 @@ function ClusterRow({
}) {
const { t } = useI18n();
const allOn = cluster.removable > 0 && cluster.selected >= cluster.removable;
const dormancy = clusterDormancy(cluster);
return (
<>
<div className="space-rule" onClick={onOpen}>
@ -169,6 +308,14 @@ function ClusterRow({
label={cluster.label}
/>
<span className="space-rule-name">{cluster.label}</span>
{dormancy !== null && dormancy >= DORMANT_SECS ? (
<span className="space-rule-dormant">
{t(
`${ageLabel(dormancy, "en").replace(" untouched", "")} dormant`,
ageLabel(dormancy, "zh").replace("未修改", "未使用"),
)}
</span>
) : null}
<span className="space-rule-cnt">
{t(
`${formatCount(cluster.entries.length)} location(s)`,
@ -217,33 +364,79 @@ function ClusterRow({
* in Explorer (电脑管家 habit: 点击定位); only the tick box changes the
* selection, so browsing never mis-toggles. */
function AccItem({ entry }: { entry: Entry }) {
const { t } = useI18n();
const { t, lang } = useI18n();
const { item, source, index } = entry;
const checked = source.selected.has(index);
const [showEvidence, setShowEvidence] = useState(false);
const evidence = item.evidence ?? [];
return (
<div
className={`space-item ${item.lock ? "is-locked" : ""}`}
onClick={() => void api.revealPath(item.path).catch(() => undefined)}
title={t("Open the location in Explorer", "在资源管理器中打开所在位置")}
>
<Checkbox
checked={checked}
disabled={Boolean(item.lock)}
onChange={() => source.toggleItem(index)}
label={item.label}
/>
<span className="space-item-name">{item.label}</span>
<span className="space-item-path" title={item.displayPath}>
{shortPath(item.displayPath, 96)}
</span>
{item.lock || item.note ? (
<span className={`space-item-meta ${item.lock ? "is-locked" : ""}`}>
{item.lock ? lockLabel(item.lock, t) : item.note}
<>
<div
className={`space-item ${item.lock ? "is-locked" : ""}`}
onClick={() => void api.revealPath(item.path).catch(() => undefined)}
title={t("Open the location in Explorer", "在资源管理器中打开所在位置")}
>
<Checkbox
checked={checked}
disabled={Boolean(item.lock)}
onChange={() => source.toggleItem(index)}
label={item.label}
/>
<span className="space-item-name">{item.label}</span>
<span className="space-item-path" title={item.displayPath}>
{shortPath(item.displayPath, 96)}
</span>
{item.lock ? (
<span className="space-item-meta is-locked">{lockLabel(item.lock, t)}</span>
) : null}
{item.lastWriteSecs != null ? (
<span
className={`space-item-meta ${item.lastWriteSecs >= DORMANT_SECS ? "is-dormant" : ""}`}
title={t(
"Newest last-write inside, from the scan walk",
"扫描时记录的内部最新写入时间",
)}
>
{ageLabel(item.lastWriteSecs, lang)}
</span>
) : null}
{evidence.length > 0 ? (
<button
type="button"
className={`space-item-evidence ${
evidence.some((token) => token.startsWith("modified:") && Number(token.slice(9)) > 0)
? "is-warn"
: ""
}`}
onClick={(event) => {
event.stopPropagation();
setShowEvidence((current) => !current);
}}
>
{showEvidence
? t("Hide evidence", "收起依据")
: t("Why safe · evidence", "可删依据")}
</button>
) : null}
{!item.lock && item.note ? (
<span className="space-item-meta">{item.note}</span>
) : null}
<span className="space-item-size">{formatBytes(item.onDisk)}</span>
<ArrowUpRight className="space-item-go" size={14} />
</div>
{showEvidence ? (
<div className="space-evidence">
<strong>{t("Why Squid judges this folder", "Squid 对该目录的判定依据")}</strong>
<ul>
{evidenceLines(evidence, t).map((line) => (
<li key={line.text} className={line.ok ? "is-ok" : "is-warn"}>
{line.text}
</li>
))}
</ul>
</div>
) : null}
<span className="space-item-size">{formatBytes(item.onDisk)}</span>
<ArrowUpRight className="space-item-go" size={14} />
</div>
</>
);
}
@ -289,6 +482,10 @@ export function SpacePage({
if (scanning || deleting || inFlight.current) return;
inFlight.current = true;
setResult(null);
// A fresh scan supersedes any armed inline confirm: the old selection
// (and its preflight verdict) no longer describes what is on screen.
setInlineConfirm(false);
setPreflight(null);
const rootList = roots
.split(/\r?\n/)
.map((root) => root.trim())
@ -570,6 +767,8 @@ export function SpacePage({
} finally {
setBusy(false);
setConfirming(false);
setInlineConfirm(false);
setPreflight(null);
}
setResult(merged);
push(
@ -582,12 +781,150 @@ export function SpacePage({
};
const progress = cleanup.progress ?? purge.progress;
// A①: running "已统计 N 文件 · X GB" counters streamed by the engines.
const liveStats = cleanup.stats ?? purge.stats;
// A②: category skeletons filled live while the scan is still measuring.
const liveBuckets = useMemo(() => {
const merged: Partial<Record<Category, { total: number; count: number }>> = {};
for (const source of [cleanup, purge]) {
for (const [category, bucket] of Object.entries(source.buckets)) {
const known = merged[category as Category];
merged[category as Category] = known
? { total: known.total + bucket.total, count: known.count + bucket.count }
: { ...bucket };
}
}
return merged;
}, [cleanup.buckets, purge.buckets]);
const stage = cleanup.scanning
? t("Scanning caches and junk", "第一步 · 扫描缓存与垃圾")
: purge.scanning
? t("Scanning project folders", "第二步 · 扫描项目目录")
: t("Collecting results", "正在汇总结果");
// A④ + B1: low-risk runs confirm inline on the sticky bar; anything with
// update installers, many items, or preflight surprises opens the modal.
const [inlineConfirm, setInlineConfirm] = useState(false);
const [preflight, setPreflight] = useState<PreflightResult | null>(null);
const [preflightBusy, setPreflightBusy] = useState(false);
// Mole's inline strip: Esc backs out of the armed confirm.
useEffect(() => {
if (!inlineConfirm) return;
const onKey = (event: KeyboardEvent) => {
if (event.key === "Escape") setInlineConfirm(false);
};
window.addEventListener("keydown", onKey);
return () => window.removeEventListener("keydown", onKey);
}, [inlineConfirm]);
const selectedPlans = () => {
const plans: Array<{ source: ScanWorkspace; indexes: number[] }> = [];
for (const source of [cleanup, purge]) {
const indexes = [...source.selected].filter((index) => {
const item = source.result?.items[index];
return item && !item.lock;
});
if (indexes.length > 0) plans.push({ source, indexes });
}
return plans;
};
const runPreflight = async () => {
const plans = selectedPlans();
if (plans.length === 0) return null;
setPreflightBusy(true);
const blocked: PreflightResult["blocked"] = [];
let checked = 0;
try {
for (const plan of plans) {
const scanId = plan.source.result?.scanId;
if (!scanId) continue;
try {
const verdict = await api.cleanupPreflight(scanId, plan.indexes);
checked += verdict.checked;
blocked.push(...verdict.blocked);
} catch {
// A failed re-check must never block the run; delete re-guards anyway.
}
}
} finally {
setPreflightBusy(false);
}
const verdict = { checked, blocked };
setPreflight(verdict);
return verdict;
};
const startClean = async () => {
const verdict = await runPreflight();
const risky =
selectedUpdaters.count > 0 ||
selectedStats.count > 40 ||
(verdict?.blocked.length ?? 0) > 0;
if (risky) {
setConfirming(true);
} else {
setInlineConfirm(true);
}
};
// B5: export the current selection as a reviewable Markdown list.
const exportList = async () => {
const lines: string[] = [
`# squid-clean-list · ${new Date().toLocaleString()} · ${t(
`${formatCount(selectedStats.count)} items ${formatBytes(selectedStats.total)}`,
`已选 ${formatCount(selectedStats.count)} 项 ${formatBytes(selectedStats.total)}`,
)}`,
"",
];
for (const source of [cleanup, purge]) {
for (const index of [...source.selected].sort((a, b) => a - b)) {
const item = source.result?.items[index];
if (!item || item.lock) continue;
const evidence =
item.evidence && item.evidence.length > 0
? ` · ${item.evidence.join(" · ")}`
: "";
lines.push(
`- [${categoryLabel(item.category, lang, bin)}] ${item.displayPath} — ${formatBytes(
item.onDisk,
)}${item.note ? ` · ${item.note}` : ""}${evidence}`,
);
}
}
lines.push("");
const locked = entries.filter((entry) => entry.item.lock === "protected");
if (locked.length > 0) {
lines.push(
t("## Protected (not deleted)", "## 受保护项(未列入删除)"),
...locked
.slice(0, 20)
.map(
(entry) =>
`- ${entry.item.displayPath} — ${formatBytes(entry.item.onDisk)} · ${
entry.item.note ?? lockLabel(entry.item.lock, t)
}`,
),
);
}
const chosen = await save({
title: t("Export clean list", "导出清理清单"),
defaultPath: "squid-clean-list.md",
filters: [{ name: "Markdown", extensions: ["md", "txt"] }],
});
if (!chosen) return;
try {
await api.writeTextFile(chosen, lines.join("\n"));
push(t("List exported", "清单已导出"), "success");
} catch (reason) {
push(
t(`Export failed: ${String(reason)}`, `导出失败:${String(reason)}`),
"danger",
);
}
};
const error = cleanup.error ?? purge.error;
if (result) {
@ -626,6 +963,57 @@ export function SpacePage({
</Button>
</div>
</div>
{result.skipped && result.skipped.length > 0 ? (
<div className="result-skipped">
<div className="result-skipped-head">
{t(
`${result.skipped.length} item(s) were skipped`,
`有 ${result.skipped.length} 项本次未处理`,
)}
</div>
{Object.entries(
result.skipped.reduce<Record<string, typeof result.skipped>>(
(groups, row) => {
const key = skipGroupOf(row.reason).key;
(groups[key] ??= []).push(row);
return groups;
},
{},
),
).map(([key, rows]) => {
const group = skipGroupOf(rows[0].reason);
return (
<div className="result-skip-group" key={key}>
<div className="result-skip-title">
<strong>{t(group.title[0], group.title[1])}</strong>
<span>{rows.length}</span>
</div>
<ul>
{rows.slice(0, 5).map((row) => (
<li key={row.path} title={row.reason}>
<code>{row.path}</code>
<small>{row.reason}</small>
</li>
))}
{rows.length > 5 ? (
<li className="more">
{t(`… ${rows.length - 5} more`, `… 另有 ${rows.length - 5} 项`)}
</li>
) : null}
</ul>
<div className="result-skip-foot">
<small>{t(group.hint[0], group.hint[1])}</small>
{group.action === "rescan" ? (
<Button variant="ghost" size="sm" onClick={() => void runScan()}>
{t("Scan again", "再扫一次")}
</Button>
) : null}
</div>
</div>
);
})}
</div>
) : null}
</div>
);
}
@ -722,8 +1110,31 @@ export function SpacePage({
<ProgressCard
progress={progress}
title={stage}
capAt99
liveLine={liveStats ? countLabel(liveStats.files, liveStats.bytes, lang) : null}
onCancel={() => void (cleanup.scanning ? cleanup.cancel() : purge.cancel())}
/>
{Object.keys(liveBuckets).length > 0 ? (
<div className="space-live-cats">
{CATEGORY_ORDER.filter((category) => liveBuckets[category]).map((category) => {
const bucket = liveBuckets[category]!;
const meta = CATEGORY_META[category];
const Icon = meta.icon;
return (
<div key={category} className="space-live-cat">
<span className={`space-cat-icon tone-${meta.tone}`}>
<Icon size={14} />
</span>
<span className="space-live-cat-name">{categoryLabel(category, lang, bin)}</span>
<span className="space-live-cat-cnt">
{t(`${formatCount(bucket.count)} items`, `${formatCount(bucket.count)} 项`)}
</span>
<b>{formatBytes(bucket.total)}</b>
</div>
);
})}
</div>
) : null}
</div>
) : null}
@ -793,24 +1204,84 @@ export function SpacePage({
)}
</div>
</div>
<Button
variant="ghost"
icon={<FileText size={14} />}
onClick={() => void exportList()}
disabled={selectedStats.count === 0}
>
{t("Export list", "导出清单")}
</Button>
<Button
variant="ghost"
onClick={() => {
cleanup.clearSelection();
purge.clearSelection();
setInlineConfirm(false);
}}
disabled={selectedStats.count === 0}
disabled={selectedStats.count === 0 || inlineConfirm}
>
{t("Deselect all", "取消全选")}
</Button>
<Button
variant="primary"
icon={<Trash2 size={16} />}
disabled={selectedStats.count === 0}
onClick={() => setConfirming(true)}
>
{t("Clean now", "立即清理")}
</Button>
{inlineConfirm ? (
<div className="space-inline-confirm">
<ShieldCheck size={16} />
<span>
<b>
{mode === "trash"
? t(
`Move to ${bin}: ${formatCount(selectedStats.count)} items · ${formatBytes(selectedStats.total)}`,
`将移入${bin}:${formatCount(selectedStats.count)} 项 · ${formatBytes(selectedStats.total)}`,
)
: t(
`Delete ${formatCount(selectedStats.count)} items · ${formatBytes(selectedStats.total)}`,
`将永久删除 ${formatCount(selectedStats.count)} 项 · ${formatBytes(selectedStats.total)}`,
)}
</b>
{preflight && preflight.blocked.length > 0 ? (
<small>
{t(
`${preflight.blocked.length} items changed since the scan and were dropped from this run`,
`其中 ${preflight.blocked.length} 项在扫描后情况变化,本次已自动移出`,
)}
</small>
) : (
<small>
{t(
"Esc cancels · every path was re-checked just now",
"按 Esc 取消 · 刚才已逐路径复核",
)}
</small>
)}
</span>
<Button
variant="ghost"
size="sm"
onClick={() => setInlineConfirm(false)}
disabled={busy}
>
{t("Cancel", "取消")}
</Button>
<Button
variant="primary"
size="sm"
disabled={busy || preflightBusy}
icon={<Trash2 size={14} />}
onClick={() => void cleanSelected()}
>
{t("Confirm clean", "确认清理")}
</Button>
</div>
) : (
<Button
variant="primary"
icon={<Trash2 size={16} />}
disabled={selectedStats.count === 0 || preflightBusy}
onClick={() => void startClean()}
>
{t("Clean now", "立即清理")}
</Button>
)}
</div>
{(["daily", "optional"] as const).map((section) => {
@ -1065,6 +1536,39 @@ export function SpacePage({
</div>
</div>
) : null}
{preflight && preflight.checked > 0 ? (
<details className="confirm-preflight">
<summary>
<ShieldCheck size={14} />
{preflight.blocked.length > 0
? t(
`Re-checked ${preflight.checked} paths just now — ${preflight.blocked.length} changed and were dropped`,
`刚刚逐路径复核过 ${preflight.checked} 项 — ${preflight.blocked.length} 项情况有变,已移出本次`,
)
: t(
`Re-checked ${preflight.checked} paths just now — all still safe to remove`,
`刚刚逐路径复核过 ${preflight.checked} 项 — 全部仍可安全删除`,
)}
</summary>
{preflight.blocked.length > 0 ? (
<ul>
{preflight.blocked.slice(0, 8).map((row) => (
<li key={row.path}>
<code>{row.path}</code>
<small>{row.reason}</small>
</li>
))}
</ul>
) : (
<p>
{t(
"Locks, whitelist, running apps and vanished paths were all re-verified at the click of this button.",
"锁、白名单、运行中的应用与已消失的路径,都在点击瞬间重新核验过。",
)}
</p>
)}
</details>
) : null}
</ConfirmDialog>
</div>
);

View File

@ -1,27 +1,31 @@
import {
ArrowLeft,
ChevronRight,
Copy,
ExternalLink,
FileArchive,
FolderOpen,
FolderSearch,
HardDrive,
Lightbulb,
LoaderCircle,
RefreshCw,
ScanSearch,
TimerReset,
} from "lucide-react";
import { useEffect, useMemo, useState } from "react";
import { open } from "@tauri-apps/plugin-dialog";
import * as apiClient from "../lib/api";
import { useI18n } from "../i18n";
import {
agoLabel,
basename,
formatBytes,
formatCount,
percent,
shortPath,
} from "../lib/format";
import type { Bootstrap, StorageNode } from "../types";
import type { Bootstrap, SpaceInsight, StorageNode } from "../types";
import { useStorageWorkspace } from "../hooks/useStorageWorkspace";
import {
Button,
@ -29,6 +33,7 @@ import {
PageHeader,
ProgressCard,
SectionTitle,
useToast,
} from "../components/ui";
const BAR_TONES = ["blue", "violet", "cyan", "teal", "orange", "pink", "indigo", "slate"];
@ -48,10 +53,28 @@ function parentDirectory(path: string): string | null {
}
export function StoragePage({ bootstrap }: { bootstrap: Bootstrap }) {
const { t } = useI18n();
const { t, lang } = useI18n();
const { push } = useToast();
const workspace = useStorageWorkspace();
const [pathInput, setPathInput] = useState("");
const [manualPath, setManualPath] = useState(false);
const [insights, setInsights] = useState<SpaceInsight[] | null>(null);
// A⑤: hidden space hogs measured quietly once per page visit.
useEffect(() => {
let alive = true;
void apiClient.api
.storageInsights()
.then((rows) => {
if (alive) setInsights(rows);
})
.catch(() => {
if (alive) setInsights([]);
});
return () => {
alive = false;
};
}, []);
useEffect(() => {
if (workspace.node && !manualPath) setPathInput(workspace.node.path);
@ -89,10 +112,19 @@ export function StoragePage({ bootstrap }: { bootstrap: Bootstrap }) {
};
const drill = (node: StorageNode) => {
if (!node.is_dir || node.path === workspace.node?.path) return;
if (!node.isDir || node.path === workspace.node?.path) return;
explore(node.path);
};
const copyCommand = async (command: string) => {
try {
await navigator.clipboard.writeText(command);
push(t("Command copied to the clipboard", "命令已复制到剪贴板"), "success");
} catch {
push(t(`Copy failed: ${command}`, `复制失败:${command}`), "danger");
}
};
const parent = workspace.node ? parentDirectory(workspace.node.path) : null;
return (
@ -180,6 +212,32 @@ export function StoragePage({ bootstrap }: { bootstrap: Bootstrap }) {
</div>
</div>
{workspace.cached ? (
<div className="storage-fresh">
<TimerReset size={13} />
<span>
{t(
`Instant open · cached measurement${
workspace.measuredAtMs
? ` · taken ${agoLabel(workspace.measuredAtMs, lang)}`
: ""
}`,
`秒开 · 缓存数据${
workspace.measuredAtMs
? ` · 上次测量 ${agoLabel(workspace.measuredAtMs, lang)}`
: ""
}`,
)}
</span>
<button
type="button"
onClick={() => void workspace.explore(workspace.node?.path, true)}
>
{t("Re-measure", "重新测量")}
</button>
</div>
) : null}
{children.length > 0 ? (
<>
<div className="storage-map" aria-label={t("Folder distribution", "文件夹占比")}>
@ -197,10 +255,10 @@ export function StoragePage({ bootstrap }: { bootstrap: Bootstrap }) {
<p className="storage-folded">
{t(
`${workspace.node.folded} smaller folders (${formatBytes(
workspace.node.folded_size,
workspace.node.foldedSize,
)}) are folded into the remainder.`,
`${workspace.node.folded} 个较小文件夹(${formatBytes(
workspace.node.folded_size,
workspace.node.foldedSize,
)})已合并显示。`,
)}
</p>
@ -213,7 +271,7 @@ export function StoragePage({ bootstrap }: { bootstrap: Bootstrap }) {
<button
key={`${child.path}-${index}`}
className={`storage-child ${
child.is_dir && child.path !== workspace.node?.path
child.isDir && child.path !== workspace.node?.path
? "is-navigable"
: ""
}`}
@ -221,7 +279,7 @@ export function StoragePage({ bootstrap }: { bootstrap: Bootstrap }) {
>
<span className={`storage-child-dot tone-${BAR_TONES[index % BAR_TONES.length]}`} />
<span className="storage-child-icon">
{child.is_dir ? <FolderOpen size={19} /> : <FileArchive size={19} />}
{child.isDir ? <FolderOpen size={19} /> : <FileArchive size={19} />}
</span>
<span className="storage-child-copy">
<strong>{basename(child.path)}</strong>
@ -256,7 +314,7 @@ export function StoragePage({ bootstrap }: { bootstrap: Bootstrap }) {
>
<ExternalLink size={14} />
</span>
{child.is_dir && child.path !== workspace.node?.path ? (
{child.isDir && child.path !== workspace.node?.path ? (
<ChevronRight size={15} />
) : null}
</span>
@ -356,6 +414,66 @@ export function StoragePage({ bootstrap }: { bootstrap: Bootstrap }) {
</>
) : null}
{insights && insights.length > 0 ? (
<section className="storage-insights">
<SectionTitle
title={t("Hidden space hogs", "隐藏的吃空间大户")}
subtitle={t(
"Things a folder scan never shows you — measured just now.",
"文件夹扫描永远看不到的占用 — 刚刚测量过。",
)}
/>
<div className="storage-insight-list">
{insights.map((insight) => (
<div className="storage-insight" key={insight.id}>
<span className="storage-insight-icon">
<Lightbulb size={16} />
</span>
<span className="storage-insight-copy">
<strong>{insight.title}</strong>
<small title={insight.path}>{shortPath(insight.path, 68)}</small>
<small className="storage-insight-hint">{insight.hint}</small>
</span>
<span className="storage-insight-size">
{insight.size > 0 ? formatBytes(insight.size) : "—"}
</span>
<span className="storage-insight-acts">
{insight.path ? (
<button
className="row-reveal"
title={t("Show in Explorer", "在资源管理器中显示")}
onClick={() => reveal(insight.path)}
>
<ExternalLink size={14} />
</button>
) : null}
{insight.action === "cleanable" ? (
<button
type="button"
className="storage-insight-cta"
onClick={() => explore(insight.path)}
>
{t("Inspect", "查看")}
</button>
) : null}
{insight.action === "command" && insight.command ? (
<button
type="button"
className="storage-insight-cta"
title={insight.command}
onClick={() => void copyCommand(insight.command!)}
>
<Copy size={13} />
{t("Copy command", "复制命令")}
</button>
) : null}
</span>
</div>
))}
</div>
</section>
) : null}
{!workspace.node && !workspace.exploring ? (
<button className="storage-start" onClick={() => explore(null)}>
<span>

View File

@ -6231,3 +6231,454 @@ html.widget-mode body {
font-size: 12.5px;
text-align: center;
}
/* ── Mole-inspired interaction batch ─────────────────────────────── */
/* A① live counters ride inside the progress card. */
.progress-live {
margin-top: 4px;
color: var(--nex-primary);
font-size: var(--nex-text-3xs);
font-weight: var(--nex-weight-semibold);
font-variant-numeric: tabular-nums;
}
/* A② category skeletons filling live during the scan. */
.space-live-cats {
display: flex;
flex-wrap: wrap;
gap: 8px;
padding: 2px 4px 0;
}
.space-live-cat {
display: flex;
align-items: center;
gap: 7px;
padding: 6px 11px;
border: 1px solid var(--nex-line);
border-radius: 10px;
background: rgba(255, 255, 255, 0.72);
animation: live-cat-in 0.25s ease;
}
@keyframes live-cat-in {
from {
opacity: 0;
transform: translateY(4px);
}
to {
opacity: 1;
transform: none;
}
}
.space-live-cat-name {
color: #42505e;
font-size: var(--nex-text-3xs);
font-weight: var(--nex-weight-semibold);
}
.space-live-cat-cnt {
color: #aab4c0;
font-size: var(--nex-text-3xs);
}
.space-live-cat b {
color: #5a6776;
font-size: var(--nex-text-3xs);
font-variant-numeric: tabular-nums;
}
/* A③ dormancy chips: green means "nobody has touched this in months". */
.space-rule-dormant {
flex: 0 0 auto;
padding: 1px 8px;
border: 1px solid #bfe0c4;
border-radius: 99px;
background: rgba(88, 170, 98, 0.08);
color: #4b8a55;
font-size: var(--nex-text-3xs);
}
.space-item-meta.is-dormant {
border-color: #bfe0c4;
color: #4b8a55;
}
/* B3 evidence chain: trigger button + the judgement panel it opens. */
.space-item-evidence {
flex: 0 0 auto;
padding: 1px 9px;
border: 1px dashed #c3ccd8;
border-radius: 99px;
background: none;
color: #6c7a87;
font-size: var(--nex-text-3xs);
cursor: pointer;
}
.space-item-evidence:hover {
border-style: solid;
color: var(--nex-primary);
}
.space-item-evidence.is-warn {
border-color: #e4c08b;
color: #b3854d;
}
.space-evidence {
margin: 0 16px 10px 74px;
padding: 10px 14px;
border: 1px solid #e4ecd6;
border-radius: 10px;
background: rgba(243, 249, 238, 0.8);
}
.space-evidence strong {
display: block;
margin-bottom: 5px;
color: #4b6a50;
font-size: var(--nex-text-3xs);
}
.space-evidence ul {
display: flex;
flex-direction: column;
gap: 3px;
margin: 0;
padding-left: 16px;
}
.space-evidence li {
color: #5f7161;
font-size: var(--nex-text-3xs);
line-height: 1.5;
}
.space-evidence li.is-ok::marker {
color: #69a873;
}
.space-evidence li.is-warn {
color: #a3672f;
}
.space-evidence li.is-warn::marker {
color: #d69a4a;
}
/* A④ inline confirm strip replacing the modal for low-risk runs. */
.space-inline-confirm {
display: flex;
align-items: center;
gap: 10px;
padding: 7px 13px;
border: 1px solid #bfe0c4;
border-radius: 12px;
background: linear-gradient(90deg, rgba(88, 170, 98, 0.12), rgba(88, 170, 98, 0.05));
color: #3f7a49;
}
.space-inline-confirm > span {
display: flex;
flex-direction: column;
gap: 1px;
}
.space-inline-confirm b {
font-size: var(--nex-text-2xs);
}
.space-inline-confirm small {
color: #6f9a76;
font-size: var(--nex-text-3xs);
}
/* B1 preflight audit panel inside the confirm modal. */
.confirm-preflight {
margin-top: 12px;
padding: 8px 12px;
border: 1px solid var(--nex-line);
border-radius: 10px;
background: rgba(255, 255, 255, 0.6);
}
.confirm-preflight summary {
display: flex;
align-items: center;
gap: 6px;
color: #4b8a55;
font-size: var(--nex-text-3xs);
cursor: pointer;
list-style: none;
}
.confirm-preflight summary::-webkit-details-marker {
display: none;
}
.confirm-preflight ul {
display: flex;
flex-direction: column;
gap: 4px;
margin: 8px 0 0;
padding-left: 20px;
}
.confirm-preflight li {
color: #a3672f;
font-size: var(--nex-text-3xs);
}
.confirm-preflight li code {
margin-right: 6px;
color: #6c7a87;
font-size: var(--nex-text-3xs);
}
.confirm-preflight p {
margin: 7px 0 0;
color: #909fad;
font-size: var(--nex-text-3xs);
line-height: 1.5;
}
/* A⑦ skipped items grouped by reason, each with its next step. */
.result-skipped {
margin-top: 18px;
padding: 14px 16px;
border: 1px solid #efe3cc;
border-radius: 14px;
background: rgba(255, 252, 244, 0.9);
}
.result-skipped-head {
margin-bottom: 10px;
color: #6c7a87;
font-size: var(--nex-text-2xs);
font-weight: var(--nex-weight-semibold);
}
.result-skip-group {
padding: 9px 0;
border-top: 1px dashed #efe3cc;
}
.result-skip-group:first-of-type {
border-top: 0;
}
.result-skip-title {
display: flex;
align-items: center;
gap: 8px;
color: #42505e;
font-size: var(--nex-text-3xs);
}
.result-skip-title span {
padding: 0 7px;
border-radius: 99px;
background: rgba(144, 159, 173, 0.14);
color: #7d8a99;
font-size: var(--nex-text-3xs);
}
.result-skip-group ul {
display: flex;
flex-direction: column;
gap: 2px;
margin: 6px 0;
padding-left: 18px;
}
.result-skip-group li {
color: #7d8a99;
font-size: var(--nex-text-3xs);
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.result-skip-group li code {
margin-right: 8px;
color: #5a6776;
}
.result-skip-group li small {
color: #b3a688;
}
.result-skip-group li.more {
list-style: none;
color: #aab4c0;
}
.result-skip-foot {
display: flex;
align-items: center;
gap: 10px;
}
.result-skip-foot small {
color: #909fad;
font-size: var(--nex-text-3xs);
}
/* A⑥ storage size-cache freshness line. */
.storage-fresh {
display: flex;
align-items: center;
gap: 7px;
margin: 6px 0 2px;
padding: 6px 10px;
border-radius: 9px;
background: rgba(47, 107, 255, 0.06);
color: #5c748f;
font-size: var(--nex-text-3xs);
}
.storage-fresh button {
margin-left: auto;
padding: 2px 10px;
border: 1px solid rgba(47, 107, 255, 0.35);
border-radius: 99px;
background: none;
color: var(--nex-primary);
font-size: var(--nex-text-3xs);
cursor: pointer;
}
.storage-fresh button:hover {
background: rgba(47, 107, 255, 0.08);
}
/* A⑤ hidden space hogs. */
.storage-insights {
margin-top: 26px;
}
.storage-insight-list {
display: flex;
flex-direction: column;
gap: 8px;
}
.storage-insight {
display: flex;
align-items: center;
gap: 12px;
padding: 10px 14px;
border: 1px solid var(--nex-line);
border-radius: 12px;
background: var(--nex-paper);
}
.storage-insight-icon {
display: inline-flex;
align-items: center;
justify-content: center;
width: 30px;
height: 30px;
flex: 0 0 auto;
border-radius: 9px;
background: rgba(214, 154, 74, 0.12);
color: #b3854d;
}
.storage-insight-copy {
display: flex;
min-width: 0;
flex: 1 1 auto;
flex-direction: column;
gap: 1px;
}
.storage-insight-copy strong {
color: #405d77;
font-size: var(--nex-text-2xs);
}
.storage-insight-copy small {
overflow: hidden;
color: #909fad;
font-size: var(--nex-text-3xs);
text-overflow: ellipsis;
white-space: nowrap;
}
.storage-insight-hint {
color: #7d8a99;
}
.storage-insight-size {
flex: 0 0 auto;
color: #5a6776;
font-size: var(--nex-text-2xs);
font-weight: var(--nex-weight-semibold);
font-variant-numeric: tabular-nums;
}
.storage-insight-acts {
display: flex;
align-items: center;
gap: 8px;
flex: 0 0 auto;
}
.storage-insight-cta {
display: inline-flex;
align-items: center;
gap: 5px;
padding: 4px 11px;
border: 1px solid rgba(47, 107, 255, 0.35);
border-radius: 99px;
background: none;
color: var(--nex-primary);
font-size: var(--nex-text-3xs);
cursor: pointer;
white-space: nowrap;
}
.storage-insight-cta:hover {
background: rgba(47, 107, 255, 0.08);
}
/* B2 whitelist consumption audit. */
.whitelist-audit-bar {
display: flex;
align-items: center;
gap: 10px;
margin-bottom: 8px;
padding: 7px 11px;
border-radius: 9px;
background: rgba(47, 107, 255, 0.05);
color: #5c748f;
font-size: var(--nex-text-3xs);
}
.whitelist-audit-bar > span {
min-width: 0;
flex: 1 1 auto;
}
.whitelist-audit-chip {
flex: 0 0 auto;
padding: 1px 8px;
border-radius: 99px;
font-size: var(--nex-text-3xs);
}
.whitelist-audit-chip.is-live {
border: 1px solid #bfe0c4;
background: rgba(88, 170, 98, 0.08);
color: #4b8a55;
}
.whitelist-audit-chip.is-dead {
border: 1px solid #e2d3e6;
background: rgba(150, 110, 170, 0.08);
color: #8a6a99;
}

View File

@ -43,6 +43,11 @@ export interface CleanupItem {
selected: boolean;
lock: LockReason | null;
note: string | null;
/** Seconds since the newest last-write inside the item (A③). */
lastWriteSecs?: number | null;
fileCount?: number;
/** Machine tokens for the B3 evidence panel ("lock:package-lock.json"). */
evidence?: string[];
}
export interface ScanResult {
@ -69,7 +74,7 @@ export interface DeleteResult {
export interface JobProgress {
jobId: string;
kind: string;
event: "phase" | "tick" | "note" | "warning" | "deleted" | "bucket";
event: "phase" | "tick" | "note" | "warning" | "deleted" | "bucket" | "metered";
phase: string | null;
detail: string | null;
done: number | null;
@ -249,14 +254,38 @@ export interface StorageNode {
allocated: number;
files: number;
dirs: number;
is_dir: boolean;
isDir: boolean;
readable: boolean;
children: StorageNode[];
folded: number;
folded_size: number;
foldedSize: number;
complete: boolean;
}
/** storage_explore now answers with freshness metadata (A⑥ size cache). */
export interface ExploreResult {
node: StorageNode;
cached: boolean;
measuredAtMs: number | null;
}
/** Hidden-space insight row (A⑤, Mole overview idiom). */
export interface SpaceInsight {
id: string;
title: string;
path: string;
size: number;
action: "cleanable" | "command" | "external" | "info";
command: string | null;
hint: string;
}
/** cleanup_preflight verdict (B1 last-second re-check). */
export interface PreflightResult {
checked: number;
blocked: { path: string; reason: string }[];
}
export interface LargestFile {
path: string;
logical: number;