cc-setup
Interactive CLI to manage MCP servers, plugins, and permissions per project in Claude Code.

Power your agent
Install from the publisher. Not a PlugMCP endpoint.
Host a copy with our keys and logs.
No packaged release in the registry yet. Follow the repository README.
Remote URL or a command on your machine? How the two installs differ
Run on PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
LaunchFrom the publisher
Interactive CLI to manage MCP servers, plugins, and permissions per project in Claude Code.

Interactive CLI to manage MCP servers for Claude Code projects
Every MCP server you enable adds its tools to Claude's context. Every plugin adds its skills. When Claude sees dozens of tools and skills, two things happen: the context window fills up with tool descriptions instead of your actual conversation, and tool selection gets noisier because the model has to pick from a larger set of candidates.
The practical effect is real. An MCP server with 20 tools that you only need in one project still consumes context in every other project. Skills from plugins you forgot you enabled compete with the ones you actually want triggered. The model does its best, but giving it a focused toolset for each project produces better results than dumping everything in globally.
cc-setup solves this by letting you define all your servers and plugins once in a central registry, then selectively enable only the ones each project needs. A Kubernetes project gets your cluster tools. A documentation project gets your writing tools. Nothing more. The Permissions tab takes this further by letting you control exactly which tools Claude can auto-approve, with profile presets for common workflows like research-only or full autonomy.
.mcp.json files, with visual distinction.mcp.json) and user-global (~/.claude.json) configsHomebrew (recommended):
brew install cc-deck/tap/cc-setup
Install script (alternative):
curl -fsSL https://raw.githubusercontent.com/cc-deck/cc-setup/main/install.sh | sh
curl -fsSL https://raw.githubusercontent.com/cc-deck/cc-setup/main/install.sh | sh
The install script detects your OS and architecture (amd64/arm64), downloads the correct binary, verifies the SHA256 checksum, and installs to ~/.local/bin.
To install to a different location:
INSTALL_DIR=/usr/local/bin curl -fsSL https://raw.githubusercontent.com/cc-deck/cc-setup/main/install.sh | sudo sh
Pre-built binaries for all platforms are available on the Releases page.
To build from source:
make build
make install # installs to ~/.local/bin
No runtime dependencies. Single static binary.
# If you already have servers in Claude Code, import them
cc-setup import
# Or add a new server interactively
cc-setup add my-server
# Launch the management UI
cc-setup
All server definitions live in a single central config file:
~/.config/cc-setup/mcp.json
Respects XDG_CONFIG_HOME if set.
The format mirrors Claude Code's mcpServers entries exactly, plus a description field for display:
{
"servers": {
"my-jira": {
"description": "Company Jira instance",
"type": "http",
"url": "https://mcp-jira.example.com/mcp",
"headers": {
"Authorization": "Basic dXNlcjpwYXNz"
}
},
"filesystem": {
"description": "Local filesystem access",
"type": "stdio",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"]
}
}
}
When writing to Claude's config, the description field is stripped and everything else is copied verbatim.
See sample-servers.json for a complete example with all transport types.
cc-setup
Opens a full-screen TUI with all your registered servers. Each server shows a health indicator dot, its transport type, endpoint, and auth method.
Key bindings:
When the management screen opens, each server is probed asynchronously. Status appears as a colored dot next to the server name:
For OAuth-protected servers, the CLI automatically uses tokens stored by Claude Code (see OAuth credential reuse below).
Claude Code merges .mcp.json files from parent directories. A server defined in ~/Work/.mcp.json is effective in ~/Work/myproject/ even without a local .mcp.json. cc-setup detects these inherited servers and displays them alongside locally configured ones, so the management screen reflects the actual effective state.
How it works:
When in project scope, cc-setup walks from the current directory upward to the filesystem root, reading .mcp.json files along the way. Servers found in parent directories (that also exist in the central registry) appear in the list with distinct visual styling:
Inherited servers also show dimmed name and detail text when not focused, making it easy to distinguish them from locally managed servers at a glance.
Conflict resolution: If the same server appears in both the local .mcp.json and a parent directory, the local definition wins and the server is treated as non-inherited (normal styling). Among parent directories, the closest parent wins.
Save behavior for inherited servers:
.mcp.json)disabledMcpjsonServers in .claude/settings.local.json, which tells Claude Code to suppress it for this projectdisabledMcpjsonServersDetail view: Pressing e/enter on any server shows a "Source" field indicating which .mcp.json file provides the server definition.
Inheritance only applies in project scope. In user scope, inherited servers are not shown.
Enter a server's detail view (e/enter) and select "Tool permissions" to discover its tools and configure which ones Claude Code may auto-approve.
settings.local.json (project or user scope)mcp__<server>__*) is usedmcp__<server>__<tool>) are written for partial selectionsautoApprove field is kept in syncTool annotations are shown when provided by the server: read-only tools show an eye icon, destructive tools show a warning icon.
cc-setup add my-new-server
Walks through transport type, URL/command, authentication, and description in an interactive form. Writes directly to the central config.
# Remove specific servers
cc-setup remove my-server another-server
# Interactive removal (no args)
cc-setup remove
If you already have servers configured in Claude Code, import them into the central config:
cc-setup import
This reads from your project .mcp.json, user ~/.claude.json, or both, and merges them into the central config. Existing entries are not overwritten.
cc-setup version
The Plugins tab (press tab to switch) lets you control which Claude Code plugins are active per project. Unlike MCP servers, plugins are not managed through a central config. Instead, cc-setup discovers plugins directly from Claude Code's own plugin cache (~/.claude/plugins/cache/).
Installing, updating, and removing plugins is still handled by Claude Code itself. What cc-setup does is let you toggle which installed plugins are enabled or disabled, per scope.
How it works:
settings.json (user or project scope)~/.claude/settings.json) sets the baseline.claude/settings.json) stores only overrides on top of the user baselinespace/x to toggle individual plugins, a to toggle allWhy this matters: Plugins add skills to Claude's context. A plugin with 20 skills that you only need for one type of project still competes for attention in every other project. Disabling irrelevant plugins per project keeps skill selection focused.
The Permissions tab (press tab twice to reach it) provides a unified view of all Claude Code permissions across built-in tools, bash patterns, and MCP tools. It supports three-state controls, profile presets, and scope-aware inherited permissions.
Each permission has three states, cycled with space:
All 11 built-in Claude Code tools (Agent, Bash, Edit, Glob, Grep, Read, Skill, ToolSearch, WebFetch, WebSearch, Write) are always visible in the list regardless of their state.
Press m to set the Claude Code permission mode:
When bypassPermissions is active, all individual permissions are dimmed (they're meaningless since everything is auto-approved) and toggling is disabled. The saved state is preserved and restored when switching back to a normal mode.
Press p to apply a permission preset:
acceptEdits.bypassPermissions.default.Profiles discover and classify MCP tools from all configured servers using annotations (ReadOnlyHint, DestructiveHint) when available, falling back to name-based heuristics (safe prefixes like list, get, read vs unsafe prefixes like delete, write, execute).
Custom profiles can be placed as YAML files in ~/.config/cc-setup/profiles/.
Press a to add permissions with a guided flow:
Permissions follow the same scope model as servers and plugins:
~/.claude/settings.local.json): Global defaults.claude/settings.local.json): Project-specific overridesIn project scope, user-scope permissions appear as inherited (grey/dimmed). Toggling an inherited permission creates a project-level override.
On save, redundant entries are automatically cleaned up:
Bash(# ...)) removedBash(git:*) when Bash or Bash(*) exists)mcp__server__*) existsKey bindings (Permissions tab):
The tool supports all Claude Code MCP transport types:
HTTP (streamable):
{
"description": "My HTTP server",
"type": "http",
"url": "https://example.com/mcp",
"headers": {
"Authorization": "Bearer your_token"
}
}
SSE (server-sent events):
{
"description": "My SSE server",
"type": "sse",
"url": "https://example.com/sse"
}
stdio (local process):
{
"description": "Local MCP server",
"type": "stdio",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/path"],
"env": {
"SOME_VAR": "value"
}
}
MCP servers that use OAuth (like Google-authenticated servers) typically show as "auth required" (yellow dot) because the CLI has no credentials to present. When Claude Code has already authenticated with these servers, their OAuth tokens are stored in ~/.claude/.credentials.json.
cc-setup reads these stored credentials and automatically injects them as Bearer tokens when connecting to matching servers. This works transparently for health checks and tool discovery.
How it works:
Authorization headermcpOAuth credentials (matched by server name)Bearer header on every request.credentials.json so Claude Code benefits tooBehavior on failure: If no credentials are found, the token is expired and refresh fails, or any other error occurs, the CLI falls back to unauthenticated requests. This is the same behavior as before, you just see the yellow dot instead of green.
Servers with static Authorization headers configured in their definition are never wrapped with OAuth. Stdio servers are unaffected since they don't use HTTP.
The tool reads server definitions from ~/.config/cc-setup/mcp.json and writes to Claude Code's config files. When you select servers:
.mcp.json or ~/.claude.json), with the description field stripped.mcp.json)disabledMcpjsonServers in .claude/settings.local.json for the current projectThis means you can use cc-setup alongside manually configured servers without conflicts.
Interactive CLI to manage MCP servers for Claude Code projects
Tools
No tool list yet. Remote servers get one after the first health check.
FAQ
Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.
No required environment variable is listed on this record.
Cc Setup runs locally over stdio.
Last checked 2026-10-28. Interactive CLI to manage MCP servers for Claude Code projects