zencleaner 1.0.0__tar.gz

zencleaner-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZenCleaner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zencleaner-1.0.0/MANIFEST.in

@@ -0,0 +1,15 @@
+include LICENSE
+include README.md
+recursive-include zencleaner/templates *
+recursive-include zencleaner/static *
+global-exclude *.py[cod] __pycache__
+global-exclude *.exe *.spec
+prune build
+prune dist
+prune node_modules
+prune .pw_browsers
+prune .pytest_cache
+prune .test_lic
+prune .venv
+prune tests
+prune zenkeygen-cs

zencleaner-1.0.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: zencleaner
+Version: 1.0.0
+Summary: ZenCleaner - type 'zencleaner' in your terminal to open a localhost web UI that actually cleans your PC.
+Author: ZenCleaner
+License: MIT
+Project-URL: Homepage, https://github.com/zencleaner/zencleaner
+Keywords: pc-cleaner,windows,privacy,temp-files,localhost,flask,system-cleaner
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: flask>=3.0
+Requires-Dist: flask-cors>=4.0
+Dynamic: license-file
+
+# ZenCleaner 🧹
+
+> **`pip install zencleaner`** → type **`zencleaner`** in your terminal → a localhost web UI opens → click buttons → it actually cleans your PC.
+
+The website is just the remote control. The real work happens **on your own PC** via a tiny local server bound to `127.0.0.1` — nothing is sent to the internet.
+
+---
+
+## Quick start (Windows)
+
+```bash
+pip install zencleaner
+```
+
+Open a **new** terminal and type:
+
+```bash
+zencleaner
+```
+
+Your browser opens automatically at `http://127.0.0.1:8765` with the ZenCleaner web UI.
+
+## What it can clean
+
+| Task | What it does |
+|---|---|
+| Temp Files | `%TEMP%`, `C:\Windows\Temp` |
+| Prefetch | `C:\Windows\Prefetch` (admin only) |
+| Recycle Bin | Empty recycle bin |
+| Registry MRU | RunMRU, RecentDocs, ComDlg32 (safe keys only) |
+| DNS Cache | `ipconfig /flushdns` |
+| Clean All | All of the above at once |
+
+## Command-line options
+
+```
+zencleaner --help
+
+  --port PORT        Port to run on (default 8765)
+  --no-browser       Don't auto-open the browser
+  --host HOST        Bind address (default 127.0.0.1 — localhost only)
+  --no-elevate       Skip the Windows UAC admin prompt
+  --no-auto-kill     Don't kill an old ZenCleaner already on this port
+```
+
+## Admin rights
+
+Some tasks (Prefetch, Registry, Forensic) need Windows Admin. On startup ZenCleaner shows a **UAC prompt** — accept it for full power, or cancel/click `--no-elevate` and the UI still works with admin-only tasks disabled.
+
+## Security
+
+- Server binds to `127.0.0.1` only — **nobody on your network or the internet can reach it**.
+- No telemetry, no data collection, no outbound calls.
+- Every clean action is a real Python function running locally on your machine.
+
+## Stop it
+
+Press `Ctrl+C` in the terminal. The localhost site stops instantly.
+
+## License
+
+MIT — see [LICENSE](LICENSE)

zencleaner-1.0.0/README.md

@@ -0,0 +1,62 @@
+# ZenCleaner 🧹
+
+> **`pip install zencleaner`** → type **`zencleaner`** in your terminal → a localhost web UI opens → click buttons → it actually cleans your PC.
+
+The website is just the remote control. The real work happens **on your own PC** via a tiny local server bound to `127.0.0.1` — nothing is sent to the internet.
+
+---
+
+## Quick start (Windows)
+
+```bash
+pip install zencleaner
+```
+
+Open a **new** terminal and type:
+
+```bash
+zencleaner
+```
+
+Your browser opens automatically at `http://127.0.0.1:8765` with the ZenCleaner web UI.
+
+## What it can clean
+
+| Task | What it does |
+|---|---|
+| Temp Files | `%TEMP%`, `C:\Windows\Temp` |
+| Prefetch | `C:\Windows\Prefetch` (admin only) |
+| Recycle Bin | Empty recycle bin |
+| Registry MRU | RunMRU, RecentDocs, ComDlg32 (safe keys only) |
+| DNS Cache | `ipconfig /flushdns` |
+| Clean All | All of the above at once |
+
+## Command-line options
+
+```
+zencleaner --help
+
+  --port PORT        Port to run on (default 8765)
+  --no-browser       Don't auto-open the browser
+  --host HOST        Bind address (default 127.0.0.1 — localhost only)
+  --no-elevate       Skip the Windows UAC admin prompt
+  --no-auto-kill     Don't kill an old ZenCleaner already on this port
+```
+
+## Admin rights
+
+Some tasks (Prefetch, Registry, Forensic) need Windows Admin. On startup ZenCleaner shows a **UAC prompt** — accept it for full power, or cancel/click `--no-elevate` and the UI still works with admin-only tasks disabled.
+
+## Security
+
+- Server binds to `127.0.0.1` only — **nobody on your network or the internet can reach it**.
+- No telemetry, no data collection, no outbound calls.
+- Every clean action is a real Python function running locally on your machine.
+
+## Stop it
+
+Press `Ctrl+C` in the terminal. The localhost site stops instantly.
+
+## License
+
+MIT — see [LICENSE](LICENSE)

zencleaner-1.0.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zencleaner"
+version = "1.0.0"
+description = "ZenCleaner - type 'zencleaner' in your terminal to open a localhost web UI that actually cleans your PC."
+authors = [{name="ZenCleaner"}]
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+keywords = ["pc-cleaner", "windows", "privacy", "temp-files", "localhost", "flask", "system-cleaner"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Systems Administration",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "flask>=3.0",
+    "flask-cors>=4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/zencleaner/zencleaner"
+
+[project.scripts]
+zencleaner = "zencleaner.cli:main"
+zenkeygen = "zencleaner.keygen_app:main"
+
+[tool.setuptools.packages.find]
+include = ["zencleaner*"]
+
+[tool.setuptools.package-data]
+zencleaner = ["templates/*", "static/*"]

zencleaner-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zencleaner-1.0.0/zencleaner/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

zencleaner-1.0.0/zencleaner/cleaner.py

@@ -0,0 +1,387 @@
+"""
+ZenCleaner forensic cleaner - all 20 buttons + string cleaner
+Each function returns {success, message, details}
+"""
+import os, shutil, subprocess, sys, glob, sqlite3, pathlib, re, json, time
+import ctypes
+from pathlib import Path
+
+def is_admin():
+    try:
+        if ctypes.windll.shell32.IsUserAnAdmin() != 0:
+            return True
+    except: pass
+    try:
+        subprocess.check_call(["net","session"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return True
+    except: return False
+
+
+def clean_memory_address(process_id, memory_address, length=100):
+    try:
+        process_id = int(process_id)
+        length = max(1, int(length))
+    except (TypeError, ValueError):
+        return {"success": False, "message": "Process ID and length must be numeric.", "details": {}}
+
+    try:
+        if isinstance(memory_address, str):
+            value = memory_address.strip()
+            if value.lower().startswith("0x"):
+                base = 16
+                value = value[2:]
+            else:
+                base = 10
+            address = int(value, base)
+        else:
+            address = int(memory_address)
+    except (TypeError, ValueError):
+        return {"success": False, "message": "Memory address is invalid. Use a decimal or hex value.", "details": {}}
+
+    try:
+        kernel32 = ctypes.windll.kernel32
+        handle = kernel32.OpenProcess(0x0010 | 0x0008 | 0x0400, False, process_id)
+        if not handle:
+            return {"success": False, "message": f"Unable to open process {process_id}.", "details": {"process_id": process_id}}
+
+        buffer = (ctypes.c_byte * length)()
+        bytes_read = ctypes.c_size_t()
+        if not kernel32.ReadProcessMemory(handle, ctypes.c_void_p(address), buffer, length, ctypes.byref(bytes_read)):
+            kernel32.CloseHandle(handle)
+            return {"success": False, "message": "ReadProcessMemory failed. Access may be denied or the address is invalid.", "details": {"process_id": process_id, "address": hex(address), "length": length}}
+
+        zeroes = (ctypes.c_byte * length)()
+        if not kernel32.WriteProcessMemory(handle, ctypes.c_void_p(address), zeroes, length, None):
+            kernel32.CloseHandle(handle)
+            return {"success": False, "message": "WriteProcessMemory failed. The process may not allow writes.", "details": {"process_id": process_id, "address": hex(address), "length": length}}
+
+        kernel32.CloseHandle(handle)
+        return {
+            "success": True,
+            "message": f"Memory cleared at {hex(address)} for process {process_id}.",
+            "details": {"process_id": process_id, "address": hex(address), "length": length},
+        }
+    except Exception as exc:
+        return {"success": False, "message": str(exc), "details": {"process_id": process_id, "address": hex(address), "length": length}}
+
+
+def clean_string(text, opts=None):
+    from .cleaner_string import string_clean
+    return string_clean(text, opts or {})
+
+
+def clean_name(name):
+    if name is None:
+        return {"success": False, "message": "Please provide a file or executable name.", "details": {}}
+
+    target = str(name).strip()
+    if not target:
+        return {"success": False, "message": "Please provide a file or executable name.", "details": {}}
+
+    target = os.path.basename(target)
+    if not target:
+        return {"success": False, "message": "Please provide a valid file or executable name.", "details": {}}
+
+    candidate_base = target.lower()
+    candidate_stem = os.path.splitext(candidate_base)[0]
+    candidate_names = {candidate_base}
+    if candidate_stem:
+        candidate_names.add(candidate_stem)
+    if not candidate_base.endswith(".exe"):
+        candidate_names.add(f"{candidate_base}.exe")
+    if candidate_stem and not candidate_stem.endswith(".exe"):
+        candidate_names.add(f"{candidate_stem}.exe")
+    search_terms = tuple(sorted({candidate_base, candidate_stem} - {""}))
+
+    roots = []
+    for env_name in ["DESKTOP", "USERPROFILE", "HOME", "TEMP", "TMP", "LOCALAPPDATA", "APPDATA", "PROGRAMDATA"]:
+        value = os.environ.get(env_name)
+        if value:
+            roots.append(value)
+    roots.extend([
+        os.path.join(os.environ.get("USERPROFILE", ""), "Desktop"),
+        os.path.join(os.environ.get("USERPROFILE", ""), "Downloads"),
+        os.path.join(os.environ.get("USERPROFILE", ""), "Documents"),
+        os.path.join(os.environ.get("LOCALAPPDATA", ""), "Temp"),
+        r"C:\Windows\Temp",
+        r"C:\Temp",
+        r"C:\Program Files",
+        r"C:\Program Files (x86)",
+        r"C:\Users",
+        r"C:\Windows",
+    ])
+    roots = list(dict.fromkeys([r for r in roots if r]))
+
+    removed = []
+    seen = set()
+
+    def matches_candidate(filename):
+        lower_name = filename.lower()
+        if lower_name in candidate_names:
+            return True
+        if candidate_stem and candidate_stem in lower_name:
+            return True
+        return False
+
+    def delete_path(path):
+        if path in seen:
+            return False
+        try:
+            if os.path.isdir(path):
+                shutil.rmtree(path)
+            else:
+                os.remove(path)
+            seen.add(path)
+            removed.append(path)
+            return True
+        except OSError:
+            return False
+
+    def contains_target_string(path):
+        try:
+            if not os.path.isfile(path):
+                return False
+            if os.path.getsize(path) > 2 * 1024 * 1024:
+                return False
+            with open(path, "rb") as handle:
+                data = handle.read()
+        except OSError:
+            return False
+
+        needle = candidate_base.encode("utf-8", "ignore")
+        lower = data.lower()
+        if needle in lower:
+            return True
+        for term in search_terms:
+            term_bytes = term.encode("utf-8", "ignore")
+            if term_bytes and term_bytes in lower:
+                return True
+        return False
+
+    try:
+        process_name = os.path.splitext(target)[0]
+        subprocess.run(["taskkill", "/F", "/IM", f"{process_name}.exe"], capture_output=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
+    except Exception:
+        pass
+
+    for root in roots:
+        if not os.path.isdir(root):
+            continue
+        for current_root, dirnames, filenames in os.walk(root):
+            for dirname in list(dirnames):
+                full_path = os.path.join(current_root, dirname)
+                if matches_candidate(dirname):
+                    delete_path(full_path)
+            for filename in filenames:
+                full_path = os.path.join(current_root, filename)
+                if matches_candidate(filename):
+                    delete_path(full_path)
+                    continue
+                if contains_target_string(full_path):
+                    delete_path(full_path)
+                    continue
+
+    try:
+        import winreg
+        registry_roots = [
+            (winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs"),
+            (winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU"),
+            (winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\OpenSavePidlMRU"),
+            (winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\LastVisitedPidlMRU"),
+            (winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist"),
+            (winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\WordWheelQuery"),
+            (winreg.HKEY_CURRENT_USER, r"Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\BagMRU"),
+            (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows\CurrentVersion\Run"),
+        ]
+        for hive, path in registry_roots:
+            try:
+                key = winreg.OpenKey(hive, path, 0, winreg.KEY_READ)
+                index = 0
+                while True:
+                    try:
+                        name, value, _ = winreg.EnumValue(key, index)
+                        index += 1
+                        combined = f"{name} {value}".lower()
+                        if candidate_base in combined or any(term and term in combined for term in search_terms):
+                            try:
+                                winreg.DeleteValue(key, name)
+                            except Exception:
+                                pass
+                    except OSError:
+                        break
+                winreg.CloseKey(key)
+            except OSError:
+                pass
+    except Exception:
+        pass
+
+    if not removed:
+        return {"success": False, "message": f"No matching file or trace for '{target}' was found.", "details": {"removed": 0, "target": target}}
+
+    return {"success": True, "message": f"Name cleanup complete: {len(removed)} match(es) removed for '{target}'.", "details": {"removed": len(removed), "target": target, "paths": removed[:20]}}
+
+
+def clean_temp():
+    return clean_windows_temp()
+
+
+def clean_recycle_bin():
+    try:
+        result = subprocess.run(
+            ["powershell", "-NoProfile", "-Command", "Clear-RecycleBin -Force -ErrorAction SilentlyContinue"],
+            capture_output=True,
+            text=True,
+            timeout=20,
+        )
+        if result.returncode in (0, 1):
+            return {"success": True, "message": "Recycle Bin cleared.", "details": {}}
+        detail = (result.stderr or result.stdout).strip() or "Recycle Bin cleanup failed."
+        return {"success": False, "message": detail, "details": {}}
+    except Exception as exc:
+        return {"success": False, "message": str(exc), "details": {}}
+
+
+def clean_registry_junk():
+    import winreg
+    cleaned = 0
+    safe_paths = [
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU",
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs",
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\LastVisitedPidlMRU",
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\OpenSavePidlMRU",
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\OpenSaveMRU",
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\WordWheelQuery",
+    ]
+    for path in safe_paths:
+        try:
+            cleaned += _clean_reg_values(winreg.HKEY_CURRENT_USER, path)[0]
+            winreg.DeleteKey(winreg.HKEY_CURRENT_USER, path)
+        except Exception:
+            pass
+    return {"success": True, "message": f"Registry junk cleared: {cleaned} entries removed.", "details": {"cleaned": cleaned}}
+
+
+def quick_health_scan():
+    temp_mb = 0.0
+    for folder in [
+        os.environ.get("TEMP", ""),
+        os.environ.get("TMP", ""),
+        r"C:\Windows\Temp",
+        os.path.join(os.environ.get("LOCALAPPDATA", ""), "Temp"),
+    ]:
+        if not folder or not os.path.isdir(folder):
+            continue
+        for root, _, files in os.walk(folder):
+            for filename in files:
+                try:
+                    temp_mb += os.path.getsize(os.path.join(root, filename)) / (1024 * 1024)
+                except OSError:
+                    pass
+    free_gb = shutil.disk_usage("C:\\").free / (1024 ** 3)
+    return {"temp_mb": round(temp_mb, 1), "free_gb": round(free_gb, 2), "is_admin": is_admin()}
+
+
+def _del_files(pattern, recursive=False):
+    c=0; f=0; sz=0
+    import glob as _g
+    for p in _g.glob(pattern, recursive=recursive):
+        try:
+            if os.path.isfile(p):
+                sz+=os.path.getsize(p); os.remove(p); c+=1
+            elif os.path.isdir(p):
+                sz+=sum(os.path.getsize(os.path.join(r,fn)) for r,_,fs in os.walk(p) for fn in fs if os.path.exists(os.path.join(r,fn)))
+                shutil.rmtree(p); c+=1
+        except: f+=1
+    return c,f,sz
+
+def _clean_reg_values(hive, path):
+    import winreg
+    cleaned=0
+    try:
+        key=winreg.OpenKey(hive, path, 0, winreg.KEY_ALL_ACCESS)
+        vals=[]
+        i=0
+        try:
+            while True: vals.append(winreg.EnumValue(key,i)[0]); i+=1
+        except OSError: pass
+        for v in vals:
+            try: winreg.DeleteValue(key,v); cleaned+=1
+            except: pass
+        winreg.CloseKey(key)
+        return cleaned, None
+    except FileNotFoundError: return 0, "not found"
+    except PermissionError as e: return 0, str(e)
+    except Exception as e: return 0, str(e)
+
+def _del_reg_tree(hive, path):
+    import winreg
+    cleaned=0
+    try:
+        key=winreg.OpenKey(hive, path, 0, winreg.KEY_READ|winreg.KEY_WRITE)
+        subs=[]
+        i=0
+        try:
+            while True: subs.append(winreg.EnumKey(key,i)); i+=1
+        except OSError: pass
+        winreg.CloseKey(key)
+        for s in subs:
+            _del_reg_tree(hive, path+"\\"+s)
+        try: winreg.DeleteKey(hive, path); cleaned+=1
+        except: pass
+    except FileNotFoundError: pass
+    except Exception: pass
+    return cleaned
+
+def clean_dns_cache():
+    try:
+        subprocess.run(["ipconfig","/flushdns"], capture_output=True, timeout=10)
+        return {"success":True,"message":"DNS cache flushed.","details":{}}
+    except Exception as e: return {"success":False,"message":str(e),"details":{}}
+
+def clean_prefetch():
+    if not is_admin(): return {"success":False,"message":"Prefetch requires Admin.","details":{}}
+    folder=r"C:\Windows\Prefetch"
+    if not os.path.isdir(folder): return {"success":False,"message":"Prefetch folder not found.","details":{}}
+    c,f,_=_del_files(os.path.join(folder,"*"))
+    return {"success":True,"message":f"Prefetch cleaned: {c} files, {f} skipped.","details":{"cleaned":c,"failed":f}}
+
+def clean_windows_temp():
+    c_tot=0; f_tot=0; sz_tot=0
+    for folder in [os.environ.get("TEMP",""), os.environ.get("TMP",""), r"C:\Windows\Temp", os.path.join(os.environ.get("LOCALAPPDATA",""),"Temp")]:
+        if not folder or not os.path.isdir(folder): continue
+        c,f,sz=_del_files(os.path.join(folder,"*"))
+        c_tot+=c; f_tot+=f; sz_tot+=sz
+    return {"success":True,"message":f"Windows Temp cleaned: {c_tot} items, {sz_tot/1024/1024:.1f} MB, {f_tot} locked.","details":{"cleaned":c_tot,"failed":f_tot}}
+
+def clean_network_usage():
+    freed=0; note=[]
+    if is_admin():
+        try: subprocess.run(["net","stop","DPS","/y"], capture_output=True, timeout=8); time.sleep(0.5)
+        except: pass
+        for p in [r"C:\Windows\System32\sru\SRUDB.dat", r"C:\Windows\System32\sru\SRUDB.dat.bak"]:
+            try:
+                if os.path.exists(p): os.remove(p); note.append(Path(p).name+" deleted")
+            except: note.append(Path(p).name+" locked")
+        try: subprocess.run(["net","start","DPS"], capture_output=True, timeout=8)
+        except: pass
+    else: note.append("SRUDB needs Admin")
+    return {"success":True,"message":"Network Usage cleaned. "+"; ".join(note) if note else "Network Usage cleaned.","details":{}}
+
+def clean_data_usage():
+    return clean_network_usage()
+
+def clean_shell_bags():
+    import winreg
+    cleaned=0
+    for path in [r"Software\Microsoft\Windows\Shell\BagMRU", r"Software\Microsoft\Windows\Shell\Bags", r"Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\BagMRU", r"Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\Bags"]:
+        try: _del_reg_tree(winreg.HKEY_CURRENT_USER, path); cleaned+=1
+        except: pass
+    return {"success":True,"message":f"Shell Bags cleaned: {cleaned} keys cleared.","details":{"cleaned":cleaned}}
+
+def clean_windows_timeline():
+    c,f,_=_del_files(os.path.join(os.environ.get("LOCALAPPDATA",""), r"ConnectedDevicesPlatform\*\ActivitiesCache.db"))
+    try:
+        import winreg
+        _clean_reg_values(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\ActivityHistory")
+    except: pass
+    return {"success":True,"message":f"Timeline cleaned: {c} db files removed.","details":{"cleaned":c}}