Storage Tool

Source Code

#!/usr/bin/env python3
import ctypes.wintypes
import os, sys, re, ctypes, threading, queue, time, math, shutil, subprocess
from pathlib import Path
from datetime import datetime, timedelta
import tkinter as tk
from tkinter import ttk, messagebox, filedialog
APP_TITLE = "Storage Tool"
VERSION = "1.1.0"
def is_windows() -> bool:
    return os.name == 'nt'
if not is_windows():
    print("This tool is Windows-only.")
    sys.exit(1)
try:
    IS_ADMIN = ctypes.windll.shell32.IsUserAnAdmin()
except Exception:
    IS_ADMIN = False
class SHFILEOPSTRUCT(ctypes.Structure):
    _fields_ = [
        ("hwnd", ctypes.wintypes.HWND),
        ("wFunc", ctypes.wintypes.UINT),
        ("pFrom", ctypes.wintypes.LPCWSTR),
        ("pTo", ctypes.wintypes.LPCWSTR),
        ("fFlags", ctypes.wintypes.USHORT),
        ("fAnyOperationsAborted", ctypes.wintypes.BOOL),
        ("hNameMappings", ctypes.wintypes.LPVOID),
        ("lpszProgressTitle", ctypes.wintypes.LPCWSTR),
    ]
FO_DELETE = 3
FOF_ALLOWUNDO = 0x0040
FOF_NOCONFIRMATION = 0x0010
FOF_SILENT = 0x0004
SHERB_NOCONFIRMATION = 0x00000001
SHERB_NOPROGRESSUI = 0x00000002
SHERB_NOSOUND = 0x00000004
USERPROFILE = Path(os.environ.get('USERPROFILE', str(Path.home())))
LOCALAPPDATA = Path(os.environ.get('LOCALAPPDATA', USERPROFILE / 'AppData/Local'))
TEMP = Path(os.environ.get('TEMP', str(LOCALAPPDATA / 'Temp')))
WINTEMP = Path(r"C:\Windows\Temp")
SOFTWAREDISTRIBUTION = Path(r"C:\Windows\SoftwareDistribution\Download")
SD_INSTALL = SOFTWAREDISTRIBUTION / "Install"
WER = Path(r"C:\ProgramData\Microsoft\Windows\WER")
LOGS = Path(r"C:\Windows\Logs")
PREFETCH = Path(r"C:\Windows\Prefetch")
BROWSER_CACHES = [
    LOCALAPPDATA / r"Microsoft/Edge/User Data/Default/Cache",
    LOCALAPPDATA / r"Google/Chrome/User Data/Default/Cache",
    LOCALAPPDATA / r"Mozilla/Firefox/Profiles",
]
def bytes_fmt(n: int) -> str:
    for unit in ['B','KB','MB','GB','TB']:
        if n < 1024:
            return f"{n:.0f} {unit}"
        n /= 1024
    return f"{n:.1f} PB"
def get_drives():
    drives = []
    bitmask = ctypes.windll.kernel32.GetLogicalDrives()
    for i in range(26):
        if bitmask & (1 << i):
            root = f"{chr(65+i)}:\\"
            type_ = ctypes.windll.kernel32.GetDriveTypeW(ctypes.c_wchar_p(root))
            if type_ == 3:
                total, used, free = shutil.disk_usage(root)
                drives.append((root, total, used, free))
    return drives
def can_recycle(path: Path) -> bool:
    return path.exists()
def recycle_path(path: Path) -> tuple[bool, str]:
    try:
        pFrom = f"{str(path)}\0\0"
        fos = SHFILEOPSTRUCT()
        fos.hwnd = 0
        fos.wFunc = FO_DELETE
        fos.pFrom = pFrom
        fos.pTo = None
        fos.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_SILENT
        res = ctypes.windll.shell32.SHFileOperationW(ctypes.byref(fos))
        if res == 0 and not fos.fAnyOperationsAborted:
            return True, "recycled"
        return False, f"shell op failed: code {res}, aborted={bool(fos.fAnyOperationsAborted)}"
    except Exception as e:
        return False, f"recycle error: {e}"
def rm_tree(path: Path) -> tuple[int, list[str]]:
    freed = 0
    errors: list[str] = []
    if not path.exists():
        return 0, []
    try:
        if path.is_file() or path.is_symlink():
            try:
                size = path.stat().st_size
            except Exception:
                size = 0
            try:
                path.unlink(missing_ok=True)
                freed += size
            except Exception as e:
                errors.append(f"{path}: {e}")
        else:
            for root, dirs, files in os.walk(path, topdown=False):
                for name in files:
                    fp = Path(root) / name
                    try:
                        size = fp.stat().st_size
                    except Exception:
                        size = 0
                    try:
                        fp.unlink(missing_ok=True)
                        freed += size
                    except Exception as e:
                        errors.append(f"{fp}: {e}")
                for name in dirs:
                    dp = Path(root) / name
                    try:
                        dp.rmdir()
                    except Exception as e:
                        errors.append(f"{dp}: {e}")
            try:
                path.rmdir()
            except Exception:
                pass
    except Exception as e:
        errors.append(f"{path}: {e}")
    return freed, errors
def dir_size(path: Path) -> int:
    total = 0
    for root, _, files in os.walk(path):
        for f in files:
            try:
                total += (Path(root)/f).stat().st_size
            except Exception:
                pass
    return total
def find_largest(start: Path, limit: int = 100, skip_system=True):
    sizes = []
    start = Path(start)
    sys_roots = {Path(r"C:\Windows"), Path(r"C:\Program Files"), Path(r"C:\Program Files (x86)")}
    for root, dirs, files in os.walk(start):
        rp = Path(root)
        if skip_system and any(str(rp).startswith(str(s)) for s in sys_roots):
            dirs[:] = []
            continue
        for name in files:
            p = rp / name
            try:
                s = p.stat().st_size
                sizes.append((p, s))
            except Exception:
                continue
    sizes.sort(key=lambda x: x[1], reverse=True)
    return sizes[:limit]
def estimate_folder(paths: list[Path]) -> int:
    total = 0
    for p in paths:
        if p.exists():
            try:
                if p.is_file():
                    total += p.stat().st_size
                else:
                    total += dir_size(p)
            except Exception:
                pass
    return total
def empty_recycle_bin() -> tuple[int, str]:
    try:
        freed_before = get_recycle_bin_size()
    except Exception:
        freed_before = 0
    try:
        ctypes.windll.shell32.SHEmptyRecycleBinW(None, None, SHERB_NOCONFIRMATION | SHERB_NOPROGRESSUI | SHERB_NOSOUND)
        return freed_before, "Recycle Bin emptied"
    except Exception as e:
        return 0, f"Failed to empty Recycle Bin: {e}"
def get_recycle_bin_size() -> int:
    total = 0
    for root, _, _ in get_drives():
        rb = Path(root) / "$Recycle.Bin"
        if rb.exists():
            total += dir_size(rb)
    return total
def stop_service(name: str) -> tuple[bool, str]:
    try:
        res = subprocess.run(["sc", "stop", name], capture_output=True, text=True, timeout=30)
        ok = res.returncode == 0 or "STOP_PENDING" in res.stdout
        return ok, res.stdout.strip() or res.stderr.strip()
    except Exception as e:
        return False, str(e)
def start_service(name: str) -> tuple[bool, str]:
    try:
        res = subprocess.run(["sc", "start", name], capture_output=True, text=True, timeout=30)
        ok = res.returncode == 0 or "RUNNING" in res.stdout
        return ok, res.stdout.strip() or res.stderr.strip()
    except Exception as e:
        return False, str(e)
def purge_software_distribution() -> tuple[int, list[str]]:
    errors = []
    freed = 0
    ok1, msg1 = stop_service("wuauserv")
    ok2, msg2 = stop_service("bits")
    if not ok1:
        errors.append(f"Stop wuauserv: {msg1}")
    if not ok2:
        errors.append(f"Stop BITS: {msg2}")
    if ok1 and ok2:
        if SOFTWAREDISTRIBUTION.exists():
            f, e = rm_tree(SOFTWAREDISTRIBUTION)
            freed += f
            errors += e
    start_service("bits")
    start_service("wuauserv")
    return freed, errors
def toggle_hibernation(enable: bool) -> tuple[bool, str]:
    if not IS_ADMIN:
        return False, "Admin required to toggle hibernation."
    try:
        arg = "/h on" if enable else "/h off"
        res = subprocess.run(["powercfg", arg], shell=True, capture_output=True, text=True)
        if res.returncode == 0:
            return True, ("Enabled" if enable else "Disabled")
        return False, res.stderr.strip() or res.stdout.strip()
    except Exception as e:
        return False, str(e)
def lcu_keep_latest_estimate() -> tuple[int, int]:
    if not SD_INSTALL.exists():
        return 0, 0
    items = list(SD_INSTALL.glob("*"))
    if not items:
        return 0, 0
    items = [p for p in items if p.exists()]
    if len(items) <= 1:
        return 0, 0
    items.sort(key=lambda p: p.stat().st_mtime, reverse=True)
    to_delete = items[1:]
    total = 0
    count = 0
    for p in to_delete:
        try:
            total += p.stat().st_size if p.is_file() else dir_size(p)
            count += 1
        except Exception:
            pass
    return total, count
def lcu_keep_latest_delete(dry_run: bool) -> tuple[int, int, list[str]]:
    if not SD_INSTALL.exists():
        return 0, 0, []
    items = list(SD_INSTALL.glob("*"))
    if len(items) <= 1:
        return 0, 0, []
    items.sort(key=lambda p: p.stat().st_mtime, reverse=True)
    to_delete = items[1:]
    total = 0
    count = 0
    errs = []
    for p in to_delete:
        try:
            if dry_run:
                total += p.stat().st_size if p.is_file() else dir_size(p)
                count += 1
            else:
                if p.is_file():
                    ok, note = recycle_path(p)
                    if ok:
                        total += p.stat().st_size
                        count += 1
                    else:
                        f, e = rm_tree(p)
                        total += f
                        count += 1
                        errs += e
                else:
                    f, e = rm_tree(p)
                    total += f
                    count += 1
                    errs += e
        except Exception as e:
            errs.append(f"{p}: {e}")
    return total, count, errs
class Logger:
    def __init__(self, widget: tk.Text):
        self.widget = widget
        self.lock = threading.Lock()
    def log(self, msg: str):
        ts = datetime.now().strftime('%H:%M:%S')
        line = f"[{ts}] {msg}\n"
        with self.lock:
            self.widget.insert(tk.END, line)
            self.widget.see(tk.END)
class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.overrideredirect(True)
        self.geometry('980x700')
        self.minsize(900, 620)
        try:
            self.iconbitmap(default='')
        except Exception:
            pass
        self.style = ttk.Style(self)
        self.style.theme_use('clam')
        self.dry_run = tk.BooleanVar(value=True)
        self.scan_limit = tk.IntVar(value=100)
        self.days_threshold = tk.IntVar(value=30)
        self._build_chrome()
        self._build_ui()
        self.center_on_screen()
        self.refresh_overview()
    def _build_chrome(self):
        self.border = tk.Frame(self, bg="#0b1220", bd=0, highlightthickness=1, highlightbackground="#2c3448")
        self.border.pack(fill=tk.BOTH, expand=True)
        self.titlebar = tk.Frame(self.border, bg="#111827")
        self.titlebar.pack(fill=tk.X, side=tk.TOP)
        self.title_label = tk.Label(self.titlebar, text=f"{APP_TITLE} — v{VERSION}", bg="#111827", fg="#e5e7eb", font=("Segoe UI", 10, "bold"))
        self.title_label.pack(side=tk.LEFT, padx=10, pady=4)
        self.dry_cb = ttk.Checkbutton(self.titlebar, text='Dry-run', variable=self.dry_run)
        self.dry_cb.pack(side=tk.LEFT, padx=8)
        self.btn_min = tk.Button(self.titlebar, text="—", command=self.minimize, bg="#111827", fg="#e5e7eb", bd=0, width=3, activebackground="#1f2937", activeforeground="#e5e7eb")
        self.btn_min.pack(side=tk.RIGHT, padx=(0,2), pady=2)
        self.btn_close = tk.Button(self.titlebar, text="✕", command=self.close, bg="#111827", fg="#e5e7eb", bd=0, width=3, activebackground="#b91c1c", activeforeground="#fff")
        self.btn_close.pack(side=tk.RIGHT, padx=(0,6), pady=2)
        self.titlebar.bind("", self.start_move)
        self.titlebar.bind("", self.do_move)
        self.title_label.bind("", self.start_move)
        self.title_label.bind("", self.do_move)
        self.body = tk.Frame(self.border, bg="#0b1220")
        self.body.pack(fill=tk.BOTH, expand=True)
        self.sizegrip = ttk.Sizegrip(self.body)
        self.sizegrip.place(relx=1.0, rely=1.0, anchor="se")
    def minimize(self):
        self.update_idletasks()
        self.overrideredirect(False)
        self.iconify()
        def reover(event):
            self.overrideredirect(True)
            self.unbind("