421 lines
15 KiB
Bash
Executable file
421 lines
15 KiB
Bash
Executable file
#!/usr/bin/env bash
|
|
#
|
|
# safeclean.sh — report and (optionally) remove regenerable junk only.
|
|
#
|
|
# Default mode is DRY-RUN: it scans, sizes everything up, and deletes NOTHING.
|
|
# Add --apply to actually delete (you'll still be asked per-category).
|
|
#
|
|
# What it targets (all regenerable / safe to lose):
|
|
# core dumps, Python caches, virtualenvs, node_modules, build targets,
|
|
# ~/.m2, gradle/pip/npm/yarn/go caches, trash, thumbnails, Docker cruft,
|
|
# and (with --system) apt cache, journald logs, old snap revisions.
|
|
#
|
|
# What it NEVER touches: your documents, media, and especially cloud-sync
|
|
# folders (Dropbox / sync / CosmoseGDrive) — those are pruned from every scan.
|
|
#
|
|
# Usage:
|
|
# ./safeclean.sh # report only (safe, default)
|
|
# ./safeclean.sh --apply # delete, asking before each category
|
|
# ./safeclean.sh --apply -y # delete without per-category prompts
|
|
# ./safeclean.sh --apply --system # also clean system stuff (uses sudo)
|
|
# ./safeclean.sh --root /path # scan a different tree (default: $HOME)
|
|
# ./safeclean.sh --days 30 # only items untouched for 30+ days (default 7)
|
|
# ./safeclean.sh --no-age # ignore age, consider everything eligible
|
|
# ./safeclean.sh -v # also list every path found
|
|
#
|
|
set -uo pipefail
|
|
|
|
# ----------------------------- configuration --------------------------------
|
|
|
|
SCAN_ROOT="$HOME"
|
|
DRY_RUN=1
|
|
ASSUME_YES=0
|
|
DO_SYSTEM=0
|
|
VERBOSE=0
|
|
AGGRESSIVE_DOCKER=0 # set via --docker-all to drop ALL unused images
|
|
AGE_DAYS=7 # only touch items NOT modified within this many days;
|
|
# set to 0 (or --no-age) to ignore age entirely
|
|
|
|
# Directories never scanned or descended into. Cloud-sync dirs are here on
|
|
# purpose: deleting a node_modules inside Dropbox would sync the deletion.
|
|
PRUNE_DIRS=(
|
|
"$HOME/Dropbox"
|
|
"$HOME/sync"
|
|
"$HOME/CosmoseGDrive"
|
|
"$HOME/.cache" # handled explicitly below
|
|
"$HOME/.local/share/Trash"
|
|
"$HOME/Android" # SDK; expensive to re-fetch
|
|
"$HOME/snap" # per-app snap data
|
|
"$HOME/.steam"
|
|
"$HOME/Steam"
|
|
)
|
|
|
|
# ------------------------------- arg parsing --------------------------------
|
|
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
--apply) DRY_RUN=0 ;;
|
|
-y|--yes) ASSUME_YES=1 ;;
|
|
--system) DO_SYSTEM=1 ;;
|
|
--docker-all) AGGRESSIVE_DOCKER=1 ;;
|
|
--days) shift; AGE_DAYS="${1:?--days needs a number}" ;;
|
|
--no-age) AGE_DAYS=0 ;;
|
|
-v|--verbose) VERBOSE=1 ;;
|
|
--root) shift; SCAN_ROOT="${1:?--root needs a path}" ;;
|
|
-h|--help)
|
|
sed -n '2,33p' "$0" | sed 's/^# \{0,1\}//'
|
|
exit 0 ;;
|
|
*) echo "unknown option: $1 (try --help)" >&2; exit 2 ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
if [ ! -d "$SCAN_ROOT" ]; then
|
|
echo "scan root '$SCAN_ROOT' is not a directory" >&2; exit 2
|
|
fi
|
|
case "$AGE_DAYS" in
|
|
''|*[!0-9]*) echo "--days needs a non-negative integer" >&2; exit 2 ;;
|
|
esac
|
|
|
|
# --------------------------------- helpers ----------------------------------
|
|
|
|
c_bold=$'\033[1m'; c_dim=$'\033[2m'; c_grn=$'\033[32m'; c_yel=$'\033[33m'; c_rst=$'\033[0m'
|
|
|
|
declare -a TARGETS
|
|
reset_targets() { TARGETS=(); }
|
|
|
|
# Refuse to ever queue something catastrophic.
|
|
safe_to_delete() {
|
|
local p="$1"
|
|
[ -n "$p" ] || return 1
|
|
[ "$p" != "/" ] || return 1
|
|
[ "$p" != "$HOME" ] || return 1
|
|
[ "$p" != "$SCAN_ROOT" ] || return 1
|
|
return 0
|
|
}
|
|
|
|
confirm() {
|
|
[ "$ASSUME_YES" = 1 ] && return 0
|
|
local ans
|
|
read -rp " ${c_yel}$1${c_rst} [y/N] " ans </dev/tty
|
|
[[ "$ans" =~ ^[Yy] ]]
|
|
}
|
|
|
|
dir_size() { # total human size of all current TARGETS
|
|
[ ${#TARGETS[@]} -eq 0 ] && { echo "0"; return; }
|
|
du -sch "${TARGETS[@]}" 2>/dev/null | tail -n1 | awk '{print $1}'
|
|
}
|
|
|
|
# True (0) if PATH has NOT been modified within AGE_DAYS, i.e. it is "old"
|
|
# enough to delete. We look at the newest file *inside* (not just the dir's
|
|
# own mtime), so an actively used venv/cache touched this week is kept.
|
|
is_old() {
|
|
[ "$AGE_DAYS" -le 0 ] && return 0 # age filter disabled
|
|
local p="$1" mins=$(( AGE_DAYS * 1440 ))
|
|
# if find turns up anything modified more recently than the window, keep it
|
|
if find "$p" -mmin "-$mins" -print -quit 2>/dev/null | grep -q .; then
|
|
return 1
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
# Keep only items in TARGETS that are old enough.
|
|
filter_by_age() {
|
|
[ "$AGE_DAYS" -le 0 ] && return
|
|
local kept=() p
|
|
for p in "${TARGETS[@]}"; do is_old "$p" && kept+=("$p"); done
|
|
TARGETS=("${kept[@]}")
|
|
}
|
|
|
|
# rm that copes with read-only trees (e.g. Go's module cache is mode 0444).
|
|
safe_rm() {
|
|
rm -rf -- "$@" 2>/dev/null && return 0
|
|
chmod -R u+w -- "$@" 2>/dev/null
|
|
rm -rf -- "$@" 2>/dev/null
|
|
}
|
|
|
|
report_and_clean() {
|
|
local label="$1"
|
|
# drop anything unsafe that slipped in
|
|
local kept=(); local p
|
|
for p in "${TARGETS[@]}"; do safe_to_delete "$p" && kept+=("$p"); done
|
|
TARGETS=("${kept[@]}")
|
|
filter_by_age # keep only items untouched for >= AGE_DAYS days
|
|
|
|
if [ ${#TARGETS[@]} -eq 0 ]; then
|
|
printf ' %-26s %snothing found%s\n' "$label" "$c_dim" "$c_rst"
|
|
return
|
|
fi
|
|
|
|
local size; size=$(dir_size)
|
|
printf ' %-26s %s%s%s %s(%d item(s))%s\n' \
|
|
"$label" "$c_bold" "$size" "$c_rst" "$c_dim" "${#TARGETS[@]}" "$c_rst"
|
|
|
|
if [ "$VERBOSE" = 1 ]; then
|
|
printf ' %s\n' "${TARGETS[@]}"
|
|
fi
|
|
|
|
[ "$DRY_RUN" = 1 ] && return
|
|
|
|
if confirm "Delete ${label} (${size})?"; then
|
|
safe_rm "${TARGETS[@]}" && printf ' %sremoved.%s\n' "$c_grn" "$c_rst"
|
|
else
|
|
echo " skipped."
|
|
fi
|
|
}
|
|
|
|
# Build the -prune expression for find from PRUNE_DIRS.
|
|
PRUNE_ARGS=()
|
|
build_prune() {
|
|
PRUNE_ARGS=(); local first=1 d
|
|
for d in "${PRUNE_DIRS[@]}"; do
|
|
if [ "$first" = 1 ]; then PRUNE_ARGS+=( -path "$d" ); first=0
|
|
else PRUNE_ARGS+=( -o -path "$d" ); fi
|
|
done
|
|
}
|
|
build_prune
|
|
|
|
# ------------------------------- scanners -----------------------------------
|
|
|
|
scan_core_dumps() {
|
|
reset_targets
|
|
local p
|
|
while IFS= read -r -d '' p; do TARGETS+=("$p"); done < <(
|
|
find "$SCAN_ROOT" -maxdepth 1 -type f \
|
|
\( -name 'core.[0-9]*' -o -name 'core' \) -print0 2>/dev/null )
|
|
report_and_clean "Core dumps"
|
|
}
|
|
|
|
scan_python_caches() {
|
|
reset_targets
|
|
local p
|
|
while IFS= read -r -d '' p; do TARGETS+=("$p"); done < <(
|
|
find "$SCAN_ROOT" \( "${PRUNE_ARGS[@]}" \) -prune -o \
|
|
-type d \( -name '__pycache__' -o -name '.pytest_cache' \
|
|
-o -name '.mypy_cache' -o -name '.ruff_cache' \
|
|
-o -name '.ipynb_checkpoints' \) -print0 2>/dev/null )
|
|
report_and_clean "Python caches"
|
|
}
|
|
|
|
scan_virtualenvs() {
|
|
reset_targets
|
|
local cfg
|
|
while IFS= read -r -d '' cfg; do TARGETS+=("$(dirname "$cfg")"); done < <(
|
|
find "$SCAN_ROOT" \( "${PRUNE_ARGS[@]}" \) -prune -o \
|
|
-type f -name 'pyvenv.cfg' -print0 2>/dev/null )
|
|
report_and_clean "Python virtualenvs"
|
|
}
|
|
|
|
scan_node_modules() {
|
|
reset_targets
|
|
local p
|
|
while IFS= read -r -d '' p; do TARGETS+=("$p"); done < <(
|
|
find "$SCAN_ROOT" \( "${PRUNE_ARGS[@]}" \) -prune -o \
|
|
-type d -name 'node_modules' -print0 -prune 2>/dev/null )
|
|
report_and_clean "node_modules"
|
|
}
|
|
|
|
scan_build_targets() {
|
|
# only 'target' dirs that sit next to a real build manifest (Rust/Maven/Gradle)
|
|
reset_targets
|
|
local p parent
|
|
while IFS= read -r -d '' p; do
|
|
parent="$(dirname "$p")"
|
|
if [ -f "$parent/Cargo.toml" ] || [ -f "$parent/pom.xml" ] \
|
|
|| [ -f "$parent/build.gradle" ] || [ -f "$parent/build.gradle.kts" ]; then
|
|
TARGETS+=("$p")
|
|
fi
|
|
done < <(
|
|
find "$SCAN_ROOT" \( "${PRUNE_ARGS[@]}" \) -prune -o \
|
|
-type d -name 'target' -print0 -prune 2>/dev/null )
|
|
report_and_clean "Build targets (rust/maven)"
|
|
}
|
|
|
|
scan_user_caches() {
|
|
reset_targets
|
|
local d
|
|
for d in \
|
|
"$HOME/.m2/repository" \
|
|
"$HOME/.gradle/caches" \
|
|
"$HOME/.cache/pip" \
|
|
"$HOME/.npm/_cacache" \
|
|
"$HOME/.cache/yarn" \
|
|
"$HOME/.platformio/.cache" \
|
|
"$HOME/.cache/thumbnails" \
|
|
"$HOME/.local/share/Trash"
|
|
do
|
|
[ -e "$d" ] && TARGETS+=("$d")
|
|
done
|
|
report_and_clean "Dev & app caches"
|
|
}
|
|
|
|
# Go's caches need their own tool: module cache files are read-only, so
|
|
# `go clean` is the correct way to drop them (with a chmod+rm fallback).
|
|
clean_go_cache() {
|
|
local modcache="$HOME/go/pkg/mod" buildcache="$HOME/.cache/go-build"
|
|
local present=()
|
|
[ -d "$modcache" ] && is_old "$modcache" && present+=("$modcache")
|
|
[ -d "$buildcache" ] && is_old "$buildcache" && present+=("$buildcache")
|
|
if [ ${#present[@]} -eq 0 ]; then
|
|
printf ' %-26s %snothing found%s\n' "Go caches" "$c_dim" "$c_rst"; return
|
|
fi
|
|
local size; size=$(du -sch "${present[@]}" 2>/dev/null | tail -n1 | awk '{print $1}')
|
|
printf ' %-26s %s%s%s\n' "Go caches" "$c_bold" "$size" "$c_rst"
|
|
[ "$DRY_RUN" = 1 ] && return
|
|
if confirm "Delete Go module + build cache (${size})?"; then
|
|
if command -v go >/dev/null 2>&1; then
|
|
go clean -modcache 2>/dev/null
|
|
go clean -cache 2>/dev/null
|
|
fi
|
|
safe_rm "${present[@]}"
|
|
printf ' %sremoved.%s\n' "$c_grn" "$c_rst"
|
|
else
|
|
echo " skipped."
|
|
fi
|
|
}
|
|
|
|
clean_docker() {
|
|
command -v docker >/dev/null 2>&1 || { printf ' %-26s %sdocker not installed%s\n' "Docker" "$c_dim" "$c_rst"; return; }
|
|
if ! docker info >/dev/null 2>&1; then
|
|
printf ' %-26s %sdaemon not reachable%s\n' "Docker" "$c_dim" "$c_rst"; return
|
|
fi
|
|
|
|
local age_h=$(( AGE_DAYS * 24 ))
|
|
|
|
echo " Docker reclaimable space:"
|
|
docker system df 2>/dev/null | sed 's/^/ /'
|
|
|
|
if [ "$DRY_RUN" = 1 ]; then
|
|
if [ "$AGGRESSIVE_DOCKER" = 0 ] && [ "$AGE_DAYS" -gt 0 ]; then
|
|
# apply uses --filter until=Xh, so docker system df overstates actual reclaim.
|
|
# Estimate: sum sizes of dangling images older than age_h hours (what prune targets).
|
|
local img_bytes=0 img_count=0 id s
|
|
while IFS= read -r id; do
|
|
[ -z "$id" ] && continue
|
|
img_count=$(( img_count + 1 ))
|
|
s=$(docker image inspect --format '{{.Size}}' "$id" 2>/dev/null) || s=0
|
|
img_bytes=$(( img_bytes + ${s:-0} ))
|
|
done < <(docker image ls --filter "dangling=true" --filter "until=${age_h}h" \
|
|
--format "{{.ID}}" 2>/dev/null)
|
|
local img_human
|
|
img_human=$(numfmt --to=si --suffix=B -- "$img_bytes" 2>/dev/null \
|
|
|| echo "${img_bytes}B")
|
|
echo
|
|
printf ' %sNOTE: apply uses --filter until=%dh — only items older than %d day(s) are removed.%s\n' \
|
|
"$c_yel" "$age_h" "$AGE_DAYS" "$c_rst"
|
|
printf ' Dangling images >%dd apply would actually remove: %s%s%s (%d image(s))\n' \
|
|
"$AGE_DAYS" "$c_bold" "$img_human" "$c_rst" "$img_count"
|
|
printf ' %s(stopped containers + build cache also contribute; totals shown above)%s\n' \
|
|
"$c_dim" "$c_rst"
|
|
printf ' %sTip: --docker-all removes ALL unused images regardless of age.%s\n' \
|
|
"$c_dim" "$c_rst"
|
|
fi
|
|
return
|
|
fi
|
|
|
|
local flags="-f"
|
|
[ "$AGGRESSIVE_DOCKER" = 1 ] && flags="-af" # -a also removes unused (not just dangling) images
|
|
local until_args=()
|
|
[ "$AGE_DAYS" -gt 0 ] && until_args=(--filter "until=${age_h}h")
|
|
if confirm "Run 'docker system prune ${flags} ${until_args[*]}' (volumes are NOT touched)?"; then
|
|
docker system prune $flags "${until_args[@]}"
|
|
else
|
|
echo " skipped."
|
|
fi
|
|
}
|
|
|
|
clean_system() {
|
|
echo
|
|
echo "${c_bold}System (sudo) ─────────────────────────────────────────────${c_rst}"
|
|
if [ "$DRY_RUN" = 1 ]; then
|
|
echo " ${c_dim}dry-run: would offer apt clean, journald vacuum, rotated log cleanup, old snap removal${c_rst}"
|
|
echo " apt archive cache:"; sudo -n du -sh /var/cache/apt/archives 2>/dev/null | sed 's/^/ /' || true
|
|
echo " journal logs:"; journalctl --disk-usage 2>/dev/null | sed 's/^/ /' || true
|
|
echo " rotated logs (/var/log/*.gz, *.1, *.2 …):"
|
|
local rot_total
|
|
rot_total=$(find /var/log -maxdepth 1 -type f \
|
|
\( -name '*.gz' -o -name '*.[0-9]' -o -name '*.[0-9][0-9]' \) \
|
|
-print0 2>/dev/null | xargs -0 -r du -sch 2>/dev/null \
|
|
| tail -n1 | awk '{print $1}') || rot_total=""
|
|
printf ' %s%s%s\n' "$c_bold" "${rot_total:-0}" "$c_rst"
|
|
return
|
|
fi
|
|
|
|
if confirm "apt: clean download cache + autoremove unused packages?"; then
|
|
sudo apt-get clean
|
|
sudo apt-get autoremove --purge -y
|
|
fi
|
|
|
|
local jdays="$AGE_DAYS"; [ "$jdays" -lt 1 ] && jdays=7
|
|
if confirm "journald: vacuum logs older than ${jdays} days?"; then
|
|
sudo journalctl --vacuum-time="${jdays}d"
|
|
fi
|
|
|
|
local rotated=()
|
|
while IFS= read -r -d '' f; do rotated+=("$f"); done < <(
|
|
find /var/log -maxdepth 1 -type f \
|
|
\( -name '*.gz' -o -name '*.[0-9]' -o -name '*.[0-9][0-9]' \) \
|
|
-print0 2>/dev/null
|
|
)
|
|
if [ ${#rotated[@]} -gt 0 ]; then
|
|
local rot_size
|
|
rot_size=$(du -sch "${rotated[@]}" 2>/dev/null | tail -n1 | awk '{print $1}')
|
|
if confirm "Delete rotated system logs (${rot_size}, ${#rotated[@]} file(s) — not active logs)?"; then
|
|
sudo rm -f -- "${rotated[@]}" && printf ' %sremoved.%s\n' "$c_grn" "$c_rst"
|
|
else
|
|
echo " skipped."
|
|
fi
|
|
fi
|
|
|
|
if confirm "snap: remove disabled (old) revisions?"; then
|
|
snap list --all 2>/dev/null | awk '/disabled/{print $1, $3}' | \
|
|
while read -r name rev; do
|
|
sudo snap remove "$name" --revision="$rev"
|
|
done
|
|
fi
|
|
}
|
|
|
|
# --------------------------------- run --------------------------------------
|
|
|
|
echo "${c_bold}safeclean${c_rst} — root: $SCAN_ROOT"
|
|
if [ "$DRY_RUN" = 1 ]; then
|
|
echo "${c_grn}DRY-RUN: reporting only, nothing will be deleted. Re-run with --apply to act.${c_rst}"
|
|
else
|
|
msg="APPLY MODE: you will be prompted before each category."
|
|
[ "$ASSUME_YES" = 1 ] && msg="APPLY MODE: deleting without prompts (auto-yes ON)."
|
|
echo "${c_yel}${msg}${c_rst}"
|
|
fi
|
|
echo
|
|
if [ "$AGE_DAYS" -gt 0 ]; then
|
|
echo "${c_dim}Age filter: only items untouched for ${AGE_DAYS}+ days are eligible (--no-age to disable).${c_rst}"
|
|
else
|
|
echo "${c_dim}Age filter: OFF — eligibility ignores file age.${c_rst}"
|
|
fi
|
|
echo
|
|
|
|
echo "${c_bold}Largest items under $SCAN_ROOT:${c_rst}"
|
|
du -h --max-depth=1 "$SCAN_ROOT" 2>/dev/null | sort -rh | head -n 12 | sed 's/^/ /'
|
|
if [ -d "${SCAN_ROOT}/.Private" ] && mount 2>/dev/null | grep -q " on ${SCAN_ROOT} type ecryptfs"; then
|
|
printf ' %sNote: eCryptfs detected — .Private and home directory are the same data; sizes above may be double-counted.%s\n' "$c_yel" "$c_rst"
|
|
fi
|
|
echo
|
|
|
|
echo "${c_bold}Reclaimable categories ──────────────────────────────────────${c_rst}"
|
|
scan_core_dumps
|
|
scan_python_caches
|
|
scan_virtualenvs
|
|
scan_node_modules
|
|
scan_build_targets
|
|
scan_user_caches
|
|
clean_go_cache
|
|
clean_docker
|
|
|
|
[ "$DO_SYSTEM" = 1 ] && clean_system
|
|
|
|
echo
|
|
if [ "$DRY_RUN" = 1 ]; then
|
|
echo "Done. (this was a dry-run — add --apply to delete)"
|
|
else
|
|
echo "Done."
|
|
fi
|