One MCP server to replace them all.

270 tools | 35 modules | 18 tool groups | Replaces 75+ MCP servers | 34MB standalone exe

Last updated: 2026-06-18 — v1.8.1 | one-time perpetual licensing (free / pro / forensics)

Compatible with Claude Desktop, Grok Desktop, Cursor, Windsurf, and any MCP client.

The official GitHub MCP server has critical SHA-handling bugs. SassyMCP's GitHub module uses correct blob SHA lookups, proper path encoding, atomic multi-file commits via Git Data API, retry logic with exponential backoff, and rate-limit awareness. It's a drop-in replacement that actually works.

The MCP ecosystem is fragmented. Need file operations? Install Filesystem server. Need terminal? Desktop Commander. GitHub? Another server. Android? Another. Screenshots? Another. You end up with 6-10 separate MCP servers, each consuming context window, each with its own config, bugs, and update cycle.

SassyMCP replaces 75+ individual MCP servers — including Desktop Commander (5.9k stars), Windows-MCP (5k stars), GitHub MCP Server (28.6k stars), Anthropic's official Filesystem and Memory servers, mobile-mcp (4.4k stars), and dozens more — with a single 34MB exe.

Key differentiators:

• Smart Tool Loading — Only loads tool groups you use. Reduces context window overhead from ~25K tokens to ~5K tokens by default.
• Dynamic Vision — Real-time screen monitoring with change detection for both desktop and Android. No more screenshot-and-pray.
• Android Interaction — Full phone control via UI accessibility tree: tap, swipe, type, with automatic sensitive context detection (auth/payment screens auto-block).
• Pause/Resume — User takes over the phone for manual steps (login, 2FA, account selection), AI watches and learns, then resumes autonomously.
• Usage Tracking — ML-lite scoring of tool invocations with exponential decay. Your most-used tools load first.
• Context Estimation — Built-in tool to measure how much of your 200K context window tool definitions consume.
• Response Minification — GitHub API responses stripped of URL metadata bloat (40-70% smaller).
• Safe Delete — Delete commands (rm, del, Remove-Item, etc.) are intercepted across all shells. Instead of destroying files, targets are moved to a _DELETE_/ staging folder in the same directory for human review — protecting against AI hallucinations.
• Self-Modification — Hot-reload modules without restart, git-backed rollback on syntax errors.
• Guided Setup — Wizard walks through persona, GitHub token, SSH credentials, and optional tool discovery.

Plus features with no MCP server equivalent: phone pause/resume with sensitive context detection (auto-blocks on login/payment screens), operational hooks (14 expert playbooks), safe delete interception, Windows autorun forensics, Android+Windows clipboard sync, usage-weighted smart loading.

SassyMCP is sold through LemonSqueezy as a one-time perpetual license (no subscriptions). Free tier runs out of the box with no key required — paid tiers unlock additional tool groups. Buy once, own forever; refunds revoke automatically.

Activation flow:

1. Purchase at https://sassyconsultingllc.com/store — LemonSqueezy emails you a key (XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX).
2. Activate from your AI agent: sassy_setup_license action=activate key=...
3. Or from a terminal: sassymcp.exe setup opens the interactive menu.
4. SassyMCP calls LS to register this machine as an instance, mints a local HMAC-signed payload, and unlocks the paid groups on the next server restart.

Offline operation: Once activated, the local HMAC payload lets SassyMCP run fully offline. A weekly authoritative re-check against LS catches refunds and cancellations; a faster startup check against the SassyMCP billing oracle cuts refund-to-revocation latency to seconds.

Safe failure modes: Missing, expired, tampered, or corrupt license files silently downgrade to free tier — the product never bricks. Network errors during activation or revalidation leave the local license intact.

Dev escape hatch: Set SASSYMCP_LICENSE_BYPASS=1 to unlock all groups regardless of license state. Intended for development on the upstream codebase, CI, and air-gapped support cases. Logged at WARNING level.

For always-on / remote deployments, run SassyMCP under its built-in supervisor instead of bare launcher scripts:

sassymcp.exe supervise start              # bridge only (127.0.0.1:21001)
sassymcp.exe supervise start --tunnel-mode managed   # also run the cloudflared tunnel as a child
sassymcp.exe supervise status             # JSON status; exit code != 0 if unhealthy
sassymcp.exe supervise stop               # graceful stop

The supervisor owns the runtime tree and makes it self-healing and orphan-proof:

• No orphans, ever. A hard kill of the supervisor (crash, kill -9, taskkill /f) takes every child with it — on Windows via a Job Object (KILL_ON_JOB_CLOSE), on Linux via process groups + PR_SET_PDEATHSIG. No leftover bridge holding a wedged SQLite/WAL lock, which is what the old taskkill-based scripts caused.
• Self-healing. Crashed children restart with exponential backoff (and give up cleanly after a crash-loop, rather than spinning).
• Catches hangs. An HTTP readiness probe recycles a hung-but-alive bridge — the failure a Windows scheduled task can never detect.
• Crash-survivable control. A pidfile + on-disk registry under $SASSYMCP_HOME mean supervise status/stop work even when the bridge is down, so an operator or agent can recover a wedged system.

start-supervised.bat wraps this as the recommended Windows launcher. stdio mode (Claude Desktop pipe) is client-owned and intentionally not supervised.

Traditional MCP screenshots are blind — you capture one frame and hope it's the right one. SassyMCP's dynamic vision changes this:

All three use grayscale + heavy JPEG compression to keep context cost minimal. A glance is ~2KB vs ~14KB for a full-color capture.

The phone isn't just a camera target — SassyMCP reads its UI accessibility tree:

Full touch input via ADB — the AI can operate the phone:

All interaction tools (tap, swipe, type) automatically scan the UI tree before executing. If they detect login screens, payment forms, account selectors, 2FA prompts, or permission dialogs, the tool refuses to execute and returns what it sees instead. The AI then describes the screen to you and asks what to do. Pass confirmed=True after explicit user approval.

AI agents can hallucinate destructive commands. SassyMCP intercepts all delete-family commands across every shell and every tool entry point, then moves targets to a _DELETE_/ staging folder instead of destroying them. Every interception is written to the audit log with the raw command, parsed targets, and move results.

Coverage — every destructive path is gated:

Intercepted command keywords: rm, rmdir, unlink (Unix/WSL), del, erase, rd (CMD), Remove-Item, ri, rni (PowerShell aliases), sdelete / sdelete64 (Sysinternals).

Also caught (beyond bare keywords):

• Shell wrappers — powershell -c "del foo", cmd /c del foo, bash -c "rm foo", wsl -- rm foo (payload is recursively scanned)
• Base64 payloads — powershell -EncodedCommand <base64> is decoded (UTF-16-LE) and recursively scanned
• .NET calls — [System.IO.File]::Delete(...), [System.IO.Directory]::Delete(...)
• Clear-Content, Set-Content -Value '' (literal empty only — normal -Value "foo" is allowed)
• Out-File -Force, New-Item -Force (overwrite-style)
• copy /y, xcopy /y — CMD silent-overwrite flags
• robocopy /MIR and robocopy /PURGE — mirror/purge modes delete destination files
• Truncate-by-redirect — > file.txt, type foo > bar.txt, cmd; > file.txt (append >> and stream 2> / &> correctly ignored)
• Move-Item foo $null
• Assignment prefixes — $null = ri foo is correctly unwrapped

Protected roots (refused by every guarded tool, not just the interceptor): the SassyMCP source tree itself, ~/.sassymcp/ (audit + config), and any _DELETE_/ staging folder (no staging recursion). Protection uses resolve() so path traversal (..\), symlinks, and Windows 8.3 short names all normalize correctly before the check.

Name collisions in _DELETE_/ are handled automatically with counter suffixes (file.txt, file_1.txt, file_2.txt). On Windows, paths with backslashes (C:\Users\foo\bar) are preserved correctly by the parser — no shlex mangling.

For complex flows where the user needs to take over:

Workflow:

1. AI operates phone autonomously for routine tasks
2. AI hits a login screen → sensitive context auto-blocks → AI tells the user
3. User says "hold on" → AI calls sassy_phone_pause
4. User logs in manually. AI watches via sassy_phone_ui / sassy_phone_glance
5. User says "done" → AI calls sassy_phone_resume
6. AI continues, now aware the user logged into a specific account

SassyMCP gates the shell and file tools through one policy engine (sassymcp.policy) with four modes, set via sassy_permission set_mode or the Control Panel:

A Claude-style allow / ask / deny rules layer (tool-glob + path-glob + command-regex; first match wins) overrides the mode default. The catastrophic block-list (format, mkfs, …) and the protected-path invariant (the SassyMCP source tree + ~/.sassymcp) hold in every mode, including bypass.

The Control Panel is a localhost web UI for all of the above — a live event log, the settings/mode editor, and a classifier + rules editor. It binds 127.0.0.1 only and needs the per-install token in ~/.sassymcp/control_panel.token. Start it with sassy_panel start (or set panel.enabled / SASSYMCP_PANEL=1 to launch it at boot), then open the printed http://127.0.0.1:8765/?token=… URL.

On first launch (no ~/.sassymcp/persona.md), the wizard tools are prominently available and the AI is given an onboarding playbook via the registered hook. The flow is conversational — the AI asks, you answer, it calls the tools.

Each step is independent and skippable. Just tell the AI "set up SassyMCP" or "let's get started" and it'll walk this:

Skip any step with action="skip" (where supported) — config records the skip so the AI doesn't re-prompt.

sassy_setup_wizard accepts these fields. All optional — defaults shown.

Output goes to ~/.sassymcp/persona.md (the persona module reads it on every session) and the run is recorded in ~/.sassymcp/config.json (setup_complete, setup_timestamp, setup_version). Re-run sassy_setup_wizard any time to regenerate — the persona module hot-reloads with the new profile.

The onboarding hook fires on phrases like "setup", "first time", "get started", "onboard", "new user", "set up sassymcp". Anything close to those will pull the playbook into the AI's context. If you want to drive it manually, just call sassy_setup_status first to see where you are, then walk the table above.

By default, SassyMCP only loads frequently-used tool groups. This keeps tool definitions under 5% of your context window.

# Default: loads core, github_quick, persona, meta, utility, selfmod, setup, infrastructure
uv run sassymcp

# Load everything (270 tools, ~22K tokens of context)
SASSYMCP_LOAD_ALL=1 uv run sassymcp

# Load specific groups
SASSYMCP_GROUPS=core,github_quick,android,v020 uv run sassymcp

Pick whichever entry point matches how you already work. All four converge on the same shared brain at ~/.sassymcp/ — your persona, memory, license, and audit log are visible to every connected MCP client.

Download sassymcp.dxt from the latest release, double-click — Claude Desktop installs it. On first launch, sassymcp auto-detects every other MCP client on your machine (Cursor, VS Code Copilot, Windsurf, Continue, Cline, Zed, Grok Desktop) and patches each one's config so they all see SassyMCP without you editing any JSON.

Install SassyMCP from the VS Code marketplace. The extension locates sassymcp.exe (PATH or the sassymcp.exePath setting), runs the same auto-config CLI, and adds a status bar item showing your license tier and brain health. Five commands cover Setup Wizard, Reinstall Configs, Open Audit Log, Open _DELETE_ Folder, Show Brain Status.

If you have sassymcp.exe already (from the portable zip or pip install) and want to register it with every MCP client without per-client JSON editing:

sassymcp-install

That detects Claude Desktop, VS Code Copilot, Cursor, Windsurf, Continue, Cline, Zed, and Grok Desktop and patches each one's config atomically. Re-running is a noop. Take a look first with sassymcp-install --dry-run. Remove with sassymcp-install --uninstall. The CLI takes a timestamped backup of any existing config before its first edit.

No installer required, but you'll edit each client's JSON yourself unless you also run sassymcp-install after.

1. Download sassymcp-v1.3.1-portable.zip from the latest release (~123 MB — includes sassymcp.exe, adb, nmap, plink, scrcpy, tesseract, cloudflared, and the start-*.bat launchers).
2. Extract anywhere — D:\Tools\SassyMCP, a thumb drive, your home folder, whatever.
3. Run start-local.bat (Claude Desktop), start-lan.bat (LAN HTTP), or start-tunnel.bat (Cloudflare Tunnel).

To uninstall: delete the folder. To upgrade: extract the new zip over the old folder, or to a new folder and delete the old one.

If you don't need the bundled nmap / adb / cloudflared (or you have them on PATH already), grab just sassymcp.exe (~35 MB) from the latest release. Drop it anywhere and point your MCP client at it.

First-run wizard: Double-click sassymcp.exe (or run it from a terminal with no flags) on a fresh machine and you'll get an interactive menu — auto-detect AI agents and register SassyMCP, activate a LemonSqueezy license key, generate / list bearer tokens, or start the HTTP server. Run sassymcp.exe setup anytime to re-open the menu. Once a persona is configured, bare invocation falls back to starting the HTTP server (the v1.5 behavior) so existing setups are unchanged.

There is no separate "licensed download" — everyone runs the same binary from the GitHub releases. Buy a license at sassyconsultingllc.com/store, then activate it on top of the free install — paid groups unlock on the next server restart:

# from your AI agent:
sassy_setup_license action=activate key=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
# or from a terminal — interactive menu, choose "Activate license":
sassymcp.exe setup

The license registers this machine as a LemonSqueezy instance (seat); sassy_setup_license action=deactivate frees the seat to move to another machine.

git clone https://github.com/sassyconsultingllc/SassyMCP.git
cd SassyMCP
uv sync

# Optional dependencies:
uv pip install pytesseract playwright
playwright install chromium

Want to drive SassyMCP from a remote MCP client (Claude Web, another machine)? The portable bundle ships a turnkey launcher. Full step-by-step is in docs/TUNNEL.md; the short version:

winget install Cloudflare.cloudflared          # one-time
cloudflared tunnel login                       # authenticate against your CF account
cloudflared tunnel create sassymcp             # create a named tunnel
cloudflared tunnel route dns sassymcp mcp.<your-domain>.tld
# Write ~/.cloudflared/config.yml with the ingress block (see TUNNEL.md)

[Environment]::SetEnvironmentVariable("SASSYMCP_AUTH_TOKEN", "<your token>", "User")
[Environment]::SetEnvironmentVariable(
    "SASSYMCP_ALLOWED_HOSTS",
    "mcp.<your-domain>.tld,localhost,127.0.0.1", "User")

cd D:\Tools\SassyMCP                           # wherever you extracted
.\start-tunnel.bat sassymcp                    # tunnel name as arg, or set SASSYMCP_TUNNEL_NAME

start-tunnel.bat launches the HTTP bridge on 127.0.0.1:21001 and runs cloudflared tunnel run <name> in the foreground. Nothing in the script is vendor-specific — you supply the tunnel name and the hostname. Clients send Authorization: Bearer <SASSYMCP_AUTH_TOKEN> against https://mcp.<your-domain>.tld/mcp.

For hosted-Claude clients that require OAuth 2.1 DCR/PKCE instead of a static bearer, deploy the optional Worker under sassymcp-oauth/ — copy wrangler.toml.example to wrangler.toml, fill in your hostname and KV id, and wrangler deploy. See docs/TUNNEL.md for the full OAuth section.

SassyMCP speaks standard MCP. Anything that connects works — no client-side modifications required. The portable bundle ships ready-to-edit templates under deploy/*_config.template.json. Pick the row for your client, copy the template, replace REPLACE_WITH_PATH with the absolute path to sassymcp.exe, and save it where the client expects.

Using the exe:

{
  "mcpServers": {
    "sassymcp": {
      "command": "C:\\path\\to\\sassymcp.exe",
      "env": {
        "SASSYMCP_LOAD_ALL": "1",
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

From source:

{
  "mcpServers": {
    "sassymcp": {
      "command": "uv",
      "args": ["--directory", "C:\\path\\to\\SassyMCP", "run", "sassymcp"],
      "env": {
        "SASSYMCP_LOAD_ALL": "1",
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "C:\\path\\to\\sassymcp.exe"
        }
      }
    ]
  }
}

Run the server in HTTP mode (sassymcp.exe --http, default 127.0.0.1:21001) and point your client at http://127.0.0.1:21001/mcp/. Set SASSYMCP_AUTH_TOKEN if the bind is non-loopback.

{
  "mcpServers": {
    "sassymcp": {
      "url": "http://127.0.0.1:21001/mcp/"
    }
  }
}

A few docstrings and the legacy .claude/skills/sassymcp-update.md slash-command target Claude Code specifically. Other clients ignore them and use sassy_update_* tools directly. No tool, transport, or auth path requires Claude — the server doesn't know which LLM is on the other end.

Two SassyMCP processes on the same machine — for example, a local stdio instance for Claude Desktop and a remote HTTPS instance behind a Cloudflare Tunnel for Claude Web — can clobber each other's state if they share ~/.sassymcp/. The fix is one env var per instance.

Instance A — local stdio for Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "sassymcp-local": {
      "command": "C:\\Tools\\SassyMCP\\sassymcp.exe",
      "env": {
        "SASSYMCP_LOAD_ALL": "1",
        "SASSYMCP_HOME": "C:\\Users\\<you>\\.sassymcp-local"
      }
    }
  }
}

Instance B — remote HTTPS via Cloudflare Tunnel (start-tunnel.bat + a wrapper that sets the env):

set SASSYMCP_HOME=C:\Users\<you>\.sassymcp-remote
set SASSYMCP_AUTH_TOKEN=<token-for-remote>
set PORT=21002
"%~dp0sassymcp.exe" --http --host 127.0.0.1 --port %PORT%

Then cloudflared tunnel run <name> forwards https://<your-tunnel>/mcp to 127.0.0.1:21002.

Each instance gets its own:

• persona.md — different profiles per session
• config.json — different runtime config (allowed dirs, blocked commands, etc.)
• tokens.json — different scoped auth tokens
• license.json — separate license activation
• audit.log / audit.jsonl — no interleaved writes
• crosslink.db — separate cross-session message queues
• memory.db — separate persistent memories
• tool_state.db / tool_usage.json — separate per-tool state and usage analytics
• server.crt / server.key — separate self-signed certs
• The _security protected-paths check honors SASSYMCP_HOME too — neither instance can sassy_safe_delete into the other's home

• The repo source tree (always protected from delete/overwrite by _security)
• %LOCALAPPDATA%\SassyMCP\updates\ — the updater download stage (harmless; tagged by version under it)
• The bundled tools in the portable zip (adb, nmap, cloudflared, etc.) — read-only from both instances

The legacy personal/autostart-bridge.bat + personal/register-autostart.ps1 template is gitignored — copy it, tweak the paths and the SASSYMCP_HOME for each instance, then Register-ScheduledTask once per instance.

All bundled in the beta zip package. Install separately only if using the standalone exe.

Run sassy_setup_check_tools to verify all tools are detected.

• Windows 10/11, macOS 12+, or Linux — one source, routed at the head (sassymcp._platform) to the right command per host. See Cross-platform below.
• Python 3.11+ (only if running from source; the standalone binary is self-contained — built per OS, since PyInstaller can't cross-compile)

The same SassyMCP source runs on Windows, macOS, and Linux. The host OS is resolved once at import; every tool then routes to the host-appropriate command — shells (PowerShell / zsh|bash), clipboard (Get-Clipboard / pbpaste), event log (Get-WinEvent / log show / journald), firewall (netsh / socketfilterfw / ufw), Wi-Fi, Bluetooth, window control (pywinauto / AppleScript System Events / wmctrl), SSH (plink / native ssh), package installs (winget / brew / apt), and more.

• Build: build.bat (Windows) or build.sh (macOS/Linux). Build each binary on its own OS.
• macOS permissions: window-control and screenshot tools need Accessibility and Screen Recording permission for the app running SassyMCP (System Settings → Privacy & Security).
• A handful of concepts are Windows-only by nature (raw Registry read/write/export); those report a clear message and point to the native equivalent (defaults, launchd). Forensic persistence (sassy_autorun_entries) IS cross-platform (Run keys / LaunchAgents / systemd+cron).

MIT License - Sassy Consulting LLC