A grab-bag of tools I built because I kept needing them.

I manage a few projects, databases, and I got tired of doing the same stuff manually - backups, checking logs, cleaning up junk, converting things. So I started building tools for it. First it was just backups. Then I needed a log reader. Then a way to clean up Claude Code's .claude directories that were eating my disk. Then HTML cleaning. It just keeps growing.

It's a Streamlit dashboard and a CLI. Nothing fancy, but it works for me.

The name? I wanted something that handles the maintenance stuff I keep putting off - things that should happen at least quarterly. Quarterly → Quartermaster → qmaster.

Built with Claude Code. I'm not a developer - I'm a product guy who wanted to solve real problems and see what Claude Code can do. More on that below.

• Backups - project archives, MySQL dumps, git bundles, checksums, retention, NAS sync
• Log reader - Apache and PHP logs with search, filtering, stats, export
• Claude Code cleanup - find and clean .claude directories eating your disk
• HTML cleaner - HTML to Markdown, plain text, or stripped HTML
• Web scraper - URLs to clean Markdown, with optional JS rendering
• Text sanitizer - strip personal info from text before sharing

Backups - Full and incremental project backups, MySQL dumps with encrypted passwords, git savepoints. Every backup gets a SHA256 checksum. Retention policies handle cleanup so old archives don't pile up forever. Optional sync to a NAS or external drive.

Log reading - Apache and PHP log parsing with search, severity filtering, stats. Because grep gets old when you're digging through access logs at 11 PM.

Claude Code cleanup - Scans your projects for .claude directories, shows you what's eating space, lets you clean by category or blow it all away. I built this after noticing 500+ MB of stale Claude data scattered around.

HTML cleaner - Paste or upload HTML, pick an output format: Markdown, structural HTML (classes and IDs but no style garbage), minimal HTML (barely any attributes), or plain text. Mostly use this before feeding content to AI or cleaning up docs.

Web scraper - Give it URLs and it fetches the pages, strips the cruft, and gives you clean Markdown. Can crawl an entire domain with depth limits, or just scrape a list of specific URLs. Optionally uses Playwright for JS-rendered pages that come back empty with plain requests.

Text sanitizer - Strips phone numbers, emails, and other personal info from text before you paste it into AI or share it publicly. You can unsanitize later to put the originals back.

The rest:

• Incremental and full tar.gz project archives
• MySQL/MariaDB dumps, compressed, passwords encrypted at rest
• Git savepoints and portable bundles
• Tag and pin important backups so retention doesn't delete them
• Streamlit dashboard + CLI (use whichever)
• Dashboard catches overdue backups on startup and runs them in the background
• Hourly/daily/weekly/monthly retention tiers
• SHA256 checksums on everything
• Secondary sync to NAS, external drive, whatever
• Cron scheduling
• Storage analytics with cleanup suggestions

I'll keep adding stuff as I need it.

git clone https://github.com/imisic/qmaster.git
cd qmaster

# Setup (creates venv, installs deps, copies example configs)
./setup.sh

# Configure your stuff
nano config/settings.yaml     # Storage paths, defaults
nano config/projects.yaml     # Your projects
nano config/databases.yaml    # Database connections (passwords auto-encrypt on first run)

# Run it
./run.sh                      # Dashboard at http://localhost:8501
./run.sh status               # CLI works too
./run.sh backup --all

No auth on the dashboard. It's meant for localhost. Don't put it on the internet without something in front of it.

./run.sh backup --all                         # Backup all projects
./run.sh backup --project my-website -i       # Incremental
./run.sh backup-db --all                      # All databases
./run.sh snapshot my-website -m "before refactor"  # Git + project + DB at once

./run.sh restore my-website backup.tar.gz
./run.sh restore-db my_app_db backup.sql.gz

./run.sh status
./run.sh verify --project my-website --all    # Check checksums
./run.sh cleanup --dry-run                    # See what would get deleted
./run.sh storage --detailed

./run.sh apache-logs --lines 100 --severity error
./run.sh php-logs --project my-website --summary
./run.sh sanitize                             # Strip personal info from text

# Git-specific backups
./run.sh backup-git --project my-website      # Portable git bundle
./run.sh restore-git my-website bundle.git
./run.sh backup-complete --project my-website # Everything, including hidden dirs

# Dig into a backup without restoring it
./run.sh list-files my-website backup.tar.gz
./run.sh preview-file my-website backup.tar.gz src/app.py
./run.sh restore-files my-website backup.tar.gz "*.py" --target /path

# Tagging and retention
./run.sh tag --project my-website backup.tar.gz --tags production --pin
./run.sh list-tagged
./run.sh retention --status
./run.sh backfill-checksums                   # Add checksums to old backups

# Log extras
./run.sh export-apache-logs --format csv
./run.sh php-report

Config files are in config/, gitignored. Only .example templates are tracked.

Projects (projects.yaml) - path, type, exclusions, git settings, schedule. Can auto-discover from a parent directory too.

Databases (databases.yaml) - connection details. Write passwords in plain text, Quartermaster encrypts them with Fernet on first load and swaps them for enc: values. Key is stored 0600, gitignored.

Settings (settings.yaml) - storage paths, retention, timeouts, dashboard stuff.

Linux and Windows via WSL (both tested). macOS probably works but I haven't tried - Apache log paths might need tweaking.

Needs: Python 3.10+, mysqldump, git, cron. Optional: playwright for JS-rendered web scraping.

I started small. I wanted a way to check Apache logs without digging through the terminal. Then I needed proper backups. Then database backups. Then Claude Code cleanup. Then HTML cleaning. One thing led to another and it just keeps going.

The whole thing was built with Claude Code. I'm not a developer - I work in product/telecom and wanted to see what Claude Code can actually do when you throw real problems at it. Turns out, quite a lot. I described what I needed, we went back and forth, and it kept growing.

Fair warning: when I started this, I barely understood git. Like, "what do you mean I have to stage before I commit?" levels of clueless. Branches, rebasing, pull requests - might as well have been in Latin. I'm still not fluent, but building this was probably the best git tutorial I never signed up for.

Can't promise it handles every edge case. It works for my setup: a few PHP and Python projects on WSL with MySQL. The code is here though, and if it's useful to you, cool.

Bugs and ideas welcome. See CONTRIBUTING.md.

MIT - see LICENSE.