SassyMCP

io.github.sassyconsultingllc由 GitHub 账号 sassyconsultingllc 发布v1.20.0更新于 Nov 11, 2026

One MCP server that replaces 75+ — 278 tools in a single exe, smart-loaded.

概览

AI 生成的概览

一个本地 MCP 服务器,内置 39 个模块共 278 个工具,涵盖文件、终端、GitHub、设备与截图等,意在替代多个独立服务器。

可以做什么
  • 操作本地文件并执行 shell/终端命令,受权限引擎管控
  • 执行 GitHub 操作,包括多文件提交与 blob SHA 处理
  • 控制 Android 与 iPhone 设备、截图并进行屏幕 OCR
  • 通过 SSH 在远程 Linux 上执行命令并扫描端口
  • 通过元工具完成安装向导、人设、记忆、许可与自检
  • 以 stdio、HTTP、HTTPS 或 SSE 方式运行,可选守护进程或 Cloudflare 隧道
适用场景
适合希望一次安装就覆盖大量日常开发与运维任务、而不想拼装六到十个独立 MCP 服务器的场景,也适合需要一个能通过隧道远程访问的单一服务器时使用。
运行要求
以本地进程运行:Windows、macOS 可用独立可执行文件,Linux 需通过 PyPI 安装并依赖 Python 3.11 以上。部分工具需要 ADB、nmap、plink、scrcpy、Tesseract、Chrome 等外部程序。可选凭据包括 GITHUB_TOKEN、SSH_HOST、SSH_USER、SSH_PASS,以及 HTTP 模式下的 SASSYMCP_AUTH_TOKEN。
安装前请注意
它能执行 shell 命令、删除文件并修改其他 MCP 客户端的配置文件,使用前应确认权限模式(默认 strict)与工具配置档。它会把 GitHub 与 SSH 凭据保存在进程环境变量中,并在状态目录下保存令牌、人设与审计日志。用于工作场景需商业许可,通过隧道对外暴露时必须设置认证令牌。

安装

在 SourceWeft 中

  1. 打开 控制台中的 SassyMCP,将其添加到工作区。
  2. 为需要使用其工具的对话启用该服务。

Desktop only,通过 STDIO。 STDIO 服务会启动本地进程,因此需要 SourceWeft 桌面宿主。

其他 MCP 客户端

参照 仓库 中的启动说明。

README

SassyMCP

One MCP server to replace them all.

278 tools | 39 modules | 18 tool groups | Replaces 75+ MCP servers | ~35MB standalone exe

Last updated: 2026-11-08 — v1.18.0 | free for personal use, every tool included; commercial license for work

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.

Why SassyMCP?

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 ~35MB 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.
  • Guided Setup — Wizard walks through persona, GitHub token, SSH credentials, and optional tool discovery.

What It Replaces

DomainSassyMCP ModuleReplacesTop Alternative
File operationsFileOps, Editor11 filesystem/editor MCP serversFilesystem (Anthropic official)
Shell / terminalShell, Session5 shell MCP serversDesktop Commander (5.9k stars)
Desktop automationUIAutomation, Vision9 desktop MCP serversWindows-MCP (5k stars)
GitHub / GitGitHub Quick, GitHub Full5 GitHub/Git MCP serversGitHub MCP Server (28.6k stars)
Android / phoneADB, PhoneScreen9 mobile MCP serversmobile-mcp (4.4k stars)
Network scanningNetworkAudit8 nmap/security MCP serversmcp-for-security (601 stars)
Security auditingSecurityAudit8 security MCP serversmcp-security-hub (509 stars)
SSH / remote LinuxLinux7 SSH MCP serversssh-mcp (365 stars)
Memory / stateMemory, StateManager7 memory MCP serversmcp-memory-service (1.6k stars)
OCR / screen readingVision7 OCR/vision MCP serversPaddleOCR MCP
Web inspectionWebInspector, Utility7 web/fetch MCP serversFetch (Anthropic official)
Windows systemRegistry, ProcessManager, Clipboard, EventLog, Bluetooth13 Windows MCP serversWindows-MCP (5k stars)

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.

Licensing

Free for personal use. Commercial use needs a license. Everyone runs the same build with every tool group unlocked and no key required. There is no free/pro split, no gated groups, and no crippled demo; the 278 tools in the module table below are the product, out of the box. What a commercial license changes is your right to use it for work, not which features you get.

Your situationWhat you need
Personal projects, learning, hobby automation, courseworkFree
Trying it at work to decideFree for 30 days
Using it in your job, on client work, or across a teamCommercial license, one seat per person

The full plain-English terms, including what counts as commercial use, are in LICENSING.md. The binding text is LICENSE.

It's not open source. The source is public so you can read and audit what runs on your machine, but you may not redistribute it, sell it, or host it as a service for others.

Supporter licenses (optional): individuals who want to fund development can buy a one-time supporter license through LemonSqueezy. It records a supporter badge in the startup banner, control panel, and VS Code cockpit and unlocks nothing, because nothing is locked. A supporter license does not cover commercial use. Refunds revoke the badge automatically.

Activation flow (commercial and supporter keys):

  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.

Offline operation: Once activated, a local HMAC-signed payload lets the license tier validate fully offline. A weekly re-check against LS catches refunds and cancellations; a faster startup check against the SassyMCP billing oracle cuts refund-to-revocation latency to seconds. Missing, expired, tampered, or corrupt license files just show the free label — tool availability is never affected.

Back-compat: SASSYMCP_LICENSE_BYPASS=1 (the old dev escape hatch that unlocked gated groups) is accepted and ignored — there is nothing left to bypass.

Running supervised (sassymcp supervise)

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 childsassymcp.exe supervise status             # JSON status; exit code != 0 if unhealthysassymcp.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.

Modules

ModuleToolsGroupDescription
Meta11metaContext estimation, tool usage analytics, group management
Batch1metaMulti-tool batch fan-out in a single call
FileOps10coreRead, write, search, move, copy, edit, mkdir, file info, safe delete
Shell2corePowerShell, CMD, WSL execution with syntax normalization and delete interception
UIAutomation6coreDesktop state, click, type, hotkeys, screenshots, screen info
Editor2coreSurgical find/replace, multi-edit
Audit4coreAudit log read, search, clear, false-positive tracking
Session6corePersistent terminal sessions (start, read, send, stop)
GitHub Quick6github_quickDaily-driver: push_files, get_file, issue, PR, protect
GitHub Full80github_fullComplete GitHub API: repos, issues, PRs, actions, security, gists
Persona7personaExpert-mode directives, decision framework, engineering standards
Utility11utilityEnv vars, toast, zip/tar/unzip/untar, HTTP requests, file diff
SetupWizard7setupSetup wizard, GitHub token guide, SSH setup, tool checker, license activation
ToolsManager1setupExternal tool bootstrap and detection
Observability3infrastructureHealth, metrics, tool stats
StateManager3infrastructurePersistent key-value state across sessions
RuntimeConfig5infrastructurePermission modes, runtime config, recent tool calls
Offline3infrastructureOffline fallback status and local-model handoff
Memory9memoryPersistent cross-session memory, milestones, task handoffs, pattern learning
Updater4updaterVersion checks, changelog, self-update
ADB10androidAndroid shell, packages, file transfer, logcat, screencap
PhoneScreen14androidUI tree reader, phone glance/watch, tap/swipe/type/key, pause/resume, scrcpy
iPhone6iphoneiOS device info, screenshot, syslog, apps, IPA install — experimental, needs libimobiledevice
NetworkAudit7systemnetstat, ARP, WiFi scan, port scan, DNS, traceroute
ProcessManager5systemCross-platform process list/kill, system info
Bluetooth3systemWindows + Android BT enumeration
EventLog3systemWindows Event Log + Android logcat
Clipboard4systemCross-platform clipboard sync
SecurityAudit7forensicsHash, permissions, certs, APK, firewall, Defender
Registry4forensicsRead, write, export, autorun forensics (Windows)
Vision8v020Screen capture, OCR, dynamic glance/watch/diff
AppLauncher6v020Launch apps, focus/close/resize/snap windows
WebInspector5v020Security headers, URL screenshots, tech stack detection
Crosslink7v020Cross-session messaging via HTTP API + SQLite
Coordination4v020Multi-agent coordination board and peer delegation
Linux1linuxRemote SSH execution via plink/OpenSSH
Combos3combosMulti-step workflows in one call: PR review, phone observe, codebase grep
Prompts0promptsMCP slash-menu shortcuts (no tools — prompts only)
SelfMod0—Retired stub — self-modification removed (no tools)

Counts generated from the registered tool set (278 tools across 39 modules, 18 groups; the prompts group exposes MCP prompts rather than tools).

Full per-tool reference (generated): docs/TOOLS.md.

iPhone support (experimental)

SassyMCP can talk to iPhones over USB via libimobiledevice. This is new in v1.16.0 and experimental — Android-over-ADB remains the mature path.

Prerequisites

  • Install libimobiledevice: brew install libimobiledevice (macOS) or sudo apt install libimobiledevice-utils (Linux). Windows hosts have limited support — use WSL2 or a macOS/Linux host.
  • Pair the device once: run idevicepair pair and tap Trust on the iPhone. iOS 17+ requires this pairing step before any tool will see the device.
  • If several iPhones are connected, pass the udid parameter (from sassy_iphone_list) to target one.

Tools: sassy_iphone_list, sassy_iphone_info, sassy_iphone_screenshot, sassy_iphone_syslog (bounded capture), sassy_iphone_apps, sassy_iphone_install (requires confirm='YES'). Every tool degrades gracefully when the binaries or a trusted device are missing — you'll get an install hint or a pairing reminder, never a traceback.

Dynamic Vision

Desktop (Vision module)

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

ToolPurpose
sassy_screen_glanceFast grayscale capture at ~3-6KB. Call repeatedly to "watch" the screen.
sassy_screen_watchMonitor for N seconds, returns only frames where content changed (pixel diff threshold).
sassy_screen_diffBefore/after comparison — takes frame, waits, takes another, returns both + a diff image highlighting changes.

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

Android (PhoneScreen module)

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

ToolPurpose
sassy_phone_uiReads every visible UI element — text, description, coordinates, clickable/focused/checked state. Structured data, not pixels.
sassy_phone_stateForeground app, screen on/off, battery, WiFi, notification count.
sassy_phone_glanceLow-res grayscale phone screenshot via direct pipe (~4-8KB).
sassy_phone_watchMonitors UI tree changes over duration. Returns snapshots only when elements change.

Phone Interaction

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

ToolPurpose
sassy_phone_tapTap screen coordinates
sassy_phone_swipeSwipe between two points
sassy_phone_typeType text into focused field
sassy_phone_keySend key events (HOME, BACK, ENTER, VOLUME, etc.)
sassy_phone_openLaunch an app by package name

Sensitive Context Detection

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.

Safe Delete (Delete Interception)

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:

ToolGuard
sassy_shellIntercepts delete commands, stages targets to _DELETE_/
sassy_session_send / sassy_session_startSame interceptor — persistent terminals can't bypass
sassy_linux_execRefuses destructive commands on the remote host
sassy_adb_shellRefuses destructive commands on Android device (override with allow_destructive=True)
sassy_safe_deleteExplicit staging tool — moves symlinks as symlinks (no resolve() in the move path)
sassy_write_file (rewrite mode)Snapshots existing file into _DELETE_/ before overwriting
sassy_edit_block / sassy_edit_multiRefuses protected paths, snapshots existing content to _DELETE_/<name>.pre-edit.<ts><ext> before applying
sassy_copyRefuses existing destination (no silent overwrite), refuses protected src/dst
sassy_moveRefuses silent destination overwrite, refuses protected src/dst
sassy_audit_clearRotates the audit log instead of deleting it; requires confirm='YES'

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.

ScenarioResult
rm -rf /Hard-blocked by the always-on blocklist — no move attempted
rm important.txtBlocked, file moved to ./_DELETE_/important.txt
del /q *.logBlocked, all .log files moved to ./_DELETE_/
Remove-Item -Path C:\data\oldBlocked, old moved to C:\data\_DELETE_\old
cmd /c del foo (wrapper)Blocked — payload is unwrapped and intercepted
gci *.tmp | ri (PS alias)Blocked — ri alias is matched
sassy_write_file("doc.txt", ..., "rewrite") on existing filePrior content snapshotted to _DELETE_/doc.overwrite.<ts>.txt first
ls -laExecutes normally — not a delete command

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.

Pause / Resume

For complex flows where the user needs to take over:

ToolPurpose
sassy_phone_pauseBlocks all interaction tools. Observation tools (ui, glance, watch) still work.
sassy_phone_resumeUnblocks interaction. AI picks up where it left off, informed by everything it observed during pause.

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

Permission Engine & Control Panel

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:

ModeBehavior
strictBlock destructive patterns everywhere (default)
confirmDestructive patterns return a confirm token
sandboxRelaxed gating inside the project roots; anything resolving outside the jail is refused — run an ungated model, confined to a folder
bypassAllow everything except protected paths (explicit, audited)

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.

Tool profiles

Tool profiles gate which tools an MCP session can see (tools/list) and call (tools/call) — a per-session, human-controlled subset of the catalog, managed from the Control Panel (a Profiles tab, backed by GET/POST /api/profile). There is deliberately no MCP tool that can switch or widen the profile, so a session can never escalate itself out of a restrictive profile; fan-out through sassy_batch respects the same gate.

ProfileTool groups
fullAll 18 groups (default on every start)
developermeta, core, infrastructure, utility, github_quick, github_full, v020, memory, persona, setup, updater
forensicsmeta, core, infrastructure, forensics, utility, system, memory
devicesmeta, core, infrastructure, android, iphone, utility, memory
sysadminmeta, core, infrastructure, system, linux, utility, memory, updater
readonlyEvery tool whose curated MCP annotation is readOnlyHint=true — computed per-tool, not from groups
customAn explicit group set you tick in the dashboard

Rules worth knowing:

  • Session-scoped, never persisted. A restart always comes back up on full. Profiles are a runtime seatbelt, not access control — the panel token is the trust boundary.
  • meta stays on. Its introspection tools (sassy_tool_groups, sassy_self_check, …) are the session's only window into what it can see; hiding them would strand the session with no way to inspect the gate.
  • Widening needs confirm='YES'. Any switch that would expose a currently-hidden tool is an audited escalation and requires explicit confirmation (the panel UI sends it for you, mirroring the bypass-mode convention). Narrowing never does.
  • A tool hidden from tools/list is also uncallable via tools/call — a client cannot call what it cannot see.

Guided Setup

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.

Onboarding procedure (recommended order)

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

#StepToolWhat happens
0License (optional)sassy_setup_license action="status" then action="activate" key=...Reports supporter tier. All tools are unlocked regardless — a key just registers your seat and supporter status.
1Personasassy_setup_wizardAsks the questionnaire below, generates ~/.sassymcp/persona.md, hot-reloads the persona module.
2GitHubsassy_setup_github action="check" → action="open_browser" → action="save_token" token=...Validates an existing GITHUB_TOKEN, or opens github.com/settings/tokens, walks you through scope selection, then saves and re-validates.
3SSH / Linuxsassy_setup_ssh action="check" → action="save" host=... user=... password=... → action="test"Locates plink, stores creds in process env, runs an echo round-trip to verify.
4Optional toolssassy_setup_check_toolsScans for nmap, tesseract, adb, scrcpy, plink, Chrome; reports install URLs for what's missing.
✓Status checksassy_setup_statusShows what's configured, what's still missing, and the action_required hint. Run this any time.
⚙️Auth tokenssassy_setup_generate_token client_id="claude-desktop"Generates a 32-byte URL-safe token for HTTP/tunnel mode and writes ~/.sassymcp/tokens.json.

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

The persona questionnaire

sassy_setup_wizard accepts these fields. All optional — defaults shown.

FieldValues / formatDefault
roledeveloper | sysadmin | security | devops | data | designer | manager | otherdeveloper
expertise_leveljunior | mid | senior | principal | staffsenior
specializationsComma-separated areas — e.g. "web security, cloud infra, mobile"empty
languagesComma-separated — e.g. "Python, Rust, TypeScript, Go"empty
frameworksComma-separated — e.g. "React, FastAPI, Cloudflare Workers"empty
systemsNewline-separated hostname — OS — role entriesempty
projectsNewline-separated name — status — description entriesempty
communication_styleterse (code only) | balanced (brief explanations) | verbose (detailed rationale)terse
security_posturestandard (OWASP) | hardened (+ CSP/HSTS/rate-limit) | paranoid (+ air-gap, cert pinning, zero trust)standard
mcp_clientsWhich AI tools connect — e.g. "Claude Desktop, Cursor, Grok Desktop"empty
notesFree-form text — anything else the AI should know about how you workempty

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.

Triggering the flow from your client

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.

Smart Loading

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

bash
# Default: loads core, github_quick, persona, meta, utility, setup, infrastructureuv run sassymcp
# Load everything (~22K tokens of context)SASSYMCP_LOAD_ALL=1 uv run sassymcp
# Load specific groupsSASSYMCP_GROUPS=core,github_quick,android,v020 uv run sassymcp

Available Groups

GroupModulesDefault
corefileops, shell, ui_automation, editor, audit, sessionYes
metametaYes
infrastructureobservability, state_manager, runtime_configYes
github_quickgithub_quick (6 lean tools)Yes
personapersonaYes
utilityutilityYes
setupsetup_wizard, tools_managerYes
memorymemoryYes
updaterupdaterYes
comboscombos (4 tools)No
promptsprompts (slash-menu shortcuts)Yes
github_fullgithub_ops (80 tools)No
androidadb, phone_screenNo
systemnetwork_audit, process_manager, security_audit, registry, bluetooth, eventlog, clipboardNo
v020vision, app_launcher, web_inspector, crosslinkNo
linuxlinuxNo

Install

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.

One-click via DXT (Claude Desktop)

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.

VS Code extension

Install the VS Code extension from the .vsix attached to the latest release until the Visual Studio Marketplace listing is live. The extension locates sassymcp.exe (PATH or the sassymcp.exePath setting), runs the same auto-config CLI, and adds a status bar item showing supporter-tier label and brain health. Command palette: Open Sassy Brain Cockpit, Run Setup Wizard, Reinstall Client Configs, Open Audit Log, Open _DELETE_ Folder, Show Brain Status.

Manual auto-config CLI

If you have sassymcp.exe already (from a GitHub release 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.

Portable bundle

The portable zip (sassymcp-v*-portable.zip with bundled adb, nmap, plink, scrcpy, tesseract, cloudflared, and the start-*.bat launchers) is no longer published — the release pipeline does not build it. Use the standalone executable below (and install any helper tools you need on PATH), or pip install sassymcp for the full Python install.

Standalone executable (no tools bundled)

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.

Linux (pip only)

CI publishes no Linux binary. On Linux/BSD, install the wheel: pipx install sassymcp (or pip install --user sassymcp). (The standalone executable is Windows-only; macOS ships a universal2 binary — see sassymcp-macos on the release page.) ./build.sh builds a native binary on any of them.

POSIX launchers mirror the .bat files and are plain /bin/sh, so they run on Debian/Kali/Ubuntu, Fedora/RHEL, Arch, openSUSE, Alpine, the BSDs and macOS:

ScriptPurpose
./start-local.shstdio mode (point your MCP client here)
./start-lan.shHTTP on localhost or LAN; prompts, or set BIND_ADDR / PORT / SASSYMCP_AUTH_TOKEN
./start-supervised.shHTTP under sassymcp supervise (auto-restart)
./start-tunnel.sh [NAME]HTTP bridge + cloudflared tunnel run
./autostart-bridge.sh installstart at login: systemd user unit (Linux), LaunchAgent (macOS), or an @reboot crontab line elsewhere
./deploy.shpackage dist/sassymcp + launchers into deploy-posix/

Each launcher finds SassyMCP in this order: ./sassymcp, dist/sassymcp, .venv/bin/python -m sassymcp.server, sassymcp on PATH, then python3 -m sassymcp.server.

MSI installer (manual builds only)

No MSI is published by CI — build-msi.ps1 exists for manual MSI builds (WiX 3.x) from a staged sassymcp.exe, and installer.wxs is a manual-build reference template, not a maintained installer.

Activating a license key

There is no separate "licensed download" and nothing to unlock — everyone runs the same fully-unlocked binary from the GitHub releases. Personal use needs no key. If you use SassyMCP for work, buy a commercial license (or, as an individual, an optional supporter license) at sassyconsultingllc.com/store and activate it to register your seat (what counts as commercial use):

powershell
# 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.

From source

bash
git clone https://github.com/sassyconsultingllc/SassyMCP.gitcd SassyMCPuv sync
# Optional dependencies:uv pip install pytesseract playwrightplaywright install chromium

Cloudflare Tunnel (remote access)

Want to drive SassyMCP from a remote MCP client (Claude Web, another machine)? Install cloudflared, then use the start-tunnel.bat launcher from this repo (deploy/start-tunnel.bat or the copy next to a standalone sassymcp.exe). Full step-by-step is in docs/TUNNEL.md; the short version:

powershell
winget install Cloudflare.cloudflared          # one-timecloudflared tunnel login                       # authenticate against your CF accountcloudflared tunnel create sassymcp             # create a named tunnelcloudflared 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.

MCP Client Config

SassyMCP speaks standard MCP. Anything that connects works — no client-side modifications required. Ready-to-edit templates live under deploy/*_config.template.json in this repo. 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.

ClientTransportConfig file locationTemplate
Claude Desktopstdio%APPDATA%\Claude\claude_desktop_config.json (Win) / ~/Library/Application Support/Claude/claude_desktop_config.json (mac)claude_desktop_config.template.json
Cursorstdio~/.cursor/mcp.json (global) or <project>/.cursor/mcp.json (per-project)cursor_mcp_config.template.json
Windsurfstdio~/.codeium/windsurf/mcp_config.jsonwindsurf_mcp_config.template.json
Cline (VS Code)stdioVS Code settings → cline.mcpServers (same mcpServers shape)use claude_desktop_config.template.json
Continue.devstdio~/.continue/config.json (merge under experimental.modelContextProtocolServers)continue_mcp_config.template.json
Grok DesktopHTTPGrok Desktop MCP settingsgrok_desktop_config.template.json
Any other MCP clientstdio or HTTPclient's MCP configuse the closest template; the mcpServers shape is conventional

Standard mcpServers shape (Claude Desktop, Cursor, Windsurf, Cline)

Using the exe:

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

From source:

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

Continue.dev shape (different schema)

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

HTTP / Grok Desktop / custom HTTP clients

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.

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

What's actually Claude-flavored (cosmetic only)

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.

Transport Modes

ModeCommandUse Case
Stdiosassymcp.exeClaude Desktop, Cursor (direct pipe)
HTTPsassymcp.exe --httpGrok Desktop, Windsurf (localhost:21001)
HTTP LANsassymcp.exe --http --host 0.0.0.0Multi-device (requires auth token)
HTTPSsassymcp.exe --http --sslEncrypted (auto-generates self-signed cert)
SSEsassymcp.exe --http --sseLegacy transport

Running Multiple Instances (Dual Session)

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.

Conflicts to resolve per-instance

ResourceDefaultHow to give each instance its own
HTTP port21001--port 21002 (HTTP-mode instances only)
Crosslink HTTP port9377sassy_crosslink_register port=9378
Auth tokenenv SASSYMCP_AUTH_TOKENSet per-process in launcher's env
Per-user state dir~/.sassymcpSASSYMCP_HOME=/path/to/dir ← the new env var (v1.3.4+)
SSL cert/key$SASSYMCP_HOME/server.{crt,key}Auto-isolated when SASSYMCP_HOME is set; or --ssl-cert / --ssl-key

Example: local stdio + remote tunnel side-by-side

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

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):

batch
set SASSYMCP_HOME=C:\Users\<you>\.sassymcp-remoteset 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.

What's isolated when SASSYMCP_HOME differs

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

What's still shared between instances

  • 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

Putting it in the OS (so both start at boot)

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.

Environment Variables

VariablePurpose
SASSYMCP_LOAD_ALL=1Load every tool group
SASSYMCP_GROUPS=core,androidLoad specific groups
SASSYMCP_AUTH_TOKEN=xxxBearer token for HTTP auth
SASSYMCP_DEV=1Enable live reload (dev mode)
SASSYMCP_NO_UPDATE_CHECK=1Disable the startup update check (no GitHub API call)
SASSYMCP_HOME=/path/to/dirOverride the per-user state dir (default ~/.sassymcp). Required when running multiple instances on one machine.
SASSYMCP_REPO=/path/to/repoOverride the auto-detected repo root in tools/mercury_audit_sassymcp.py (dev tool only)
GITHUB_TOKEN=xxxGitHub API access
SSH_HOST=xxxRemote Linux hostname/IP
SSH_USER=xxxRemote Linux username
SSH_PASS=xxxRemote Linux password

External Tools

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

ToolUsed ByBundledInstall (if needed)
ADBAll sassy_adb_* + sassy_phone_* toolsYesAndroid Platform Tools
nmapsassy_port_scanYesnmap.org
plinksassy_linux_execYesPuTTY
scrcpysassy_scrcpy_* toolsYesscrcpy releases
Tesseractsassy_screen_ocr, sassy_find_text_on_screenYestesseract-ocr
Chromesassy_url_screenshotNogoogle.com/chrome

Run sassy_setup_check_tools to verify all tools are detected.

Requirements

  • 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)

Cross-platform

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, firewalld, nftables, iptables, pf), Wi-Fi, Bluetooth, window control (pywinauto / AppleScript System Events / wmctrl or xdotool), SSH (plink / native ssh), package installs, and more.

On Linux and BSD, SassyMCP finds the native package manager (apt, dnf, yum, pacman, zypper, apk, xbps, emerge, pkg, pkg_add, pkgin, or Homebrew) and uses that distro's package names. When it isn't running as root it calls sudo -n, so a password prompt fails at once with a hint instead of hanging. When a tool is missing on a minimal install, SassyMCP uses another one: ss or ip neigh for net-tools, dig/host/getent for nslookup, tracepath for traceroute, and syslog files when there is no journald. The clipboard uses wl-clipboard on Wayland and xclip/xsel on X11. If pwsh is installed, shell="powershell" runs PowerShell 7 on Linux and macOS.

  • Linux window control works on X11 and on apps running under XWayland (install wmctrl or xdotool, plus xrandr). Native Wayland compositors don't let one app control another app's windows, so those tools give a clear error there.

  • 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).

License

Free for personal and educational use; commercial use requires a license. Source-available, not open source. See LICENSING.md for the plain-English terms and LICENSE for the binding text.

Copyright (c) 2026 Sassy Consulting LLC. All rights reserved.

来源:README.md,提交 5319025

工具

0
SourceWeft 尚未在沙箱中启动过该软件包,因此其工具未知。

版本历史

5
  1. v1.20.0最新Nov 11, 2026
  2. v1.18.0Oct 21, 2026
  3. v1.16.0Sep 22, 2026
  4. v1.15.2Sep 21, 2026
  5. v1.15.1Sep 16, 2026

评分

已满足适用检查项的 40%

该评分衡量此收录条目的完整程度,依据注册中心条目、端点与公开来源计算得出。它不是对服务器本身的评价,也不表示服务器安全或当前可用:可连通性是带日期的检查结果,评分也不包含安装量或用户评价。

  • 近 30 天内可连通25 分

    请保持端点能够响应 MCP 握手;SourceWeft 每 30 天探测一次。

  • 已声明认证方式10 分

    请在注册中心条目中声明凭据请求头,或保持端点能够响应探测,以便判定其认证方式。

  • 已列出工具15 分

    请让服务器在无凭据时响应 tools/list,或发布可在沙箱中无凭据启动的软件包。

  • 描述必需15 分
  • 图标10 分
  • 文档15 分
  • 许可证10 分

    请在仓库或注册中心条目中声明许可证。