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.
LaunchCLI for managing fine-grained Claude Code configuration per project.
Handles CLAUDE.md composition, plugin enablement, MCP servers, skill overrides, and rules โ without manually juggling files.
Linux x86_64 โ one line (no sudo required):
curl -fsSL https://raw.githubusercontent.com/aneveux/ccx/master/install.sh | bash
The installer drops the ccx binary into ~/.local/bin by default. Make sure that
directory is on your $PATH:
export PATH="$HOME/.local/bin:$PATH" # add to ~/.bashrc or ~/.zshrc
Override the install directory with CCX_INSTALL_DIR:
CCX_INSTALL_DIR=/usr/local/bin curl -fsSL https://raw.githubusercontent.com/aneveux/ccx/master/install.sh | bash
The installer downloads the latest Linux x86_64 binary, verifies its SHA-256
checksum before installing (fail-closed โ it aborts on a missing or mismatched
checksum), then moves the binary into the install directory. Set
CCX_SKIP_CHECKSUM=1 only if you understand the risk. Pin a specific release with
CCX_VERSION (a tag such as v0.6.0; defaults to latest).
Or download a binary directly from Releases.
ccx ships no profiles in the binary โ author your own with:
ccx profiles new my-profile
ccx profiles enable my-profile
Prerequisites: Java 25, Maven 3.9+
JVM (development):
mvn verify
java -jar target/quarkus-app/quarkus-run.jar --help
Native binary (requires GraalVM 25 with native-image):
mvn package -Pnative
./target/ccx --help
Global options. Most commands accept --project-dir (the project to act on,
defaults to cwd). Read-only commands that resolve global config also accept
--global-dir (the Claude config dir, defaults to ~/.claude): plugins list,
plugins diff, plugins tags, plugins refresh, skills list, skills show.
doctor and status also accept --global-dir, but default it to your home
directory (they resolve .claude/settings.json underneath).
doctor additionally probes for git, jq, and yq on your PATH โ a missing
git is reported as [WARNING], missing jq/yq as [INFO]. It exits 1 when
any [ERROR] is found, or when git is missing; every other [WARNING] and
[INFO] is advisory and leaves the exit code at 0. In particular a plugin that
resolves against no configured marketplace is a non-failing warning (ADR-015).
clean is a dry run by default: bare ccx clean reports the files and settings
keys it would touch and changes nothing. ccx clean --force is the destructive
form โ it strips ccx-managed keys from .claude/settings.json, removes the ccx
marker block from .claude/CLAUDE.md, deletes the rule and command files ccx
installed, and drops .ccx/context.json.
Claude Code keeps two separate pieces of state for a plugin: it is enabled by
enabledPlugins in .claude/settings.json, and it is installed by a record in
~/.claude/plugins/installed_plugins.json plus a materialized tree under
~/.claude/plugins/cache/. Enabled but not installed, Claude Code refuses to load it and
reports isn't installed here or not cached.
ccx writes the enablement and delegates the installation to
claude plugin install <plugin>@<marketplace> --scope project, run in the project directory.
Every enable path does it: plugins enable, profiles enable, profiles reinstall, and the
TUI's plugin and profile toggles (in the background, so the UI never blocks). If the claude
binary cannot be found or the install fails, the enablement is still written and the exact
command to run by hand is printed. ccx doctor reports the gap as an error, and
ccx plugins sync repairs it.
Set CCX_CLAUDE_BIN to point at the claude binary when it is not on PATH.
mcp enable adds a server or updates one that already exists. Describe the server
with flags:
# command server (--type defaults to "command")
ccx mcp enable filesystem --command mcp-server-fs --args --root --args .
# HTTP server
ccx mcp enable remote-api --type http --url https://mcp.example.com/sse
--args is repeatable โ each occurrence adds one argument. The --command,
--url, --args, and --type flags map to the command/url/args/type
fields of the server entry.
Power-user path: pass the full config as a JSON positional instead of flags.
ccx mcp enable filesystem '{"command": "mcp-server-fs", "args": ["--root", "."]}'
ccx mcp enable remote-api '{"type": "http", "url": "https://mcp.example.com/sse"}'
Manage references to global CLAUDE.md fragments inside .claude/CLAUDE.md.
A fragment named <name> must already exist at ~/.config/ccx/claudemd/<name>.md
(create one with ccx config claudemd new <name>). claude-md add writes an
absolute @<path> reference into the โฆ block.
.claude/settings.jsonThe project settings file ccx reads and writes. Only the keys ccx touches are shown; unknown keys are preserved.
{
"enabledPlugins": {
"java@my-marketplace": true
},
"permissions": {
"allow": ["Bash(mvn *)"],
"deny": ["Bash(rm -rf *)"]
},
"mcpServers": {
"filesystem": { "command": "mcp-server-fs", "args": ["--root", "."] }
},
"skillOverrides": {
"java:java": "off"
}
}
permissions, env, and ignore produceA profile declares these blocks in its profile.yaml:
permissions:
deny: ["Bash(rm -rf *)"]
env:
JAVA_HOME: /usr/lib/jvm/java-21
ignore:
- "target/"
- "*.class"
On ccx profiles enable, all three merge into .claude/settings.json. ignore
patterns are translated into Read(...) deny rules and joined with the profile's
own permissions.deny entries โ Claude Code has no separate ignore-file mechanism:
// .claude/settings.json
{
"permissions": {
"deny": ["Bash(rm -rf *)", "Read(target/**)", "Read(**/*.class)"]
},
"env": { "JAVA_HOME": "/usr/lib/jvm/java-21" }
}
The translation is purely syntactic:
An entry already written as Read(...), Write(...), or Bash(...) passes through
verbatim, so you can bypass the auto-wrapping when you want exact control.
Two things to know about the rules this produces:
Read(target/**) has no leading /, so Claude Code
resolves it relative to the current directory and, for a single-segment directory pattern
in a deny rule, matches a target directory at any depth beneath it. Read(/target/**)
would pin it to the project root only. Unanchored is the broader deny, which is what you
want from an ignore list. Write Read(/target/**) yourself if you need the narrow form.Read(...) deny rule blocks the Read and Edit
tools on the matched path, and does not apply to a file touched by an arbitrary subprocess
(Bash(cat โฆ)). Add an explicit Write(...) or Bash(...) deny entry if you need those too..ccx/context.jsonccx tracks which profiles are enabled and an installation snapshot per profile so it can detect drift. Written automatically โ you do not edit this by hand.
{
"version": "1",
"enabledProfiles": {
"java": {
"enabledAt": "2026-06-24T10:15:30Z",
"snapshot": {
"plugins": ["java@my-marketplace"],
"rules": ["no-empty-catch"],
"permissionsAllow": ["Bash(mvn *)"],
"permissionsDeny": [],
"commands": [],
"fragments": [],
"env": {},
"ignorePatterns": ["target/"]
}
}
}
}
ccx ships no profiles in the binary โ author your own (see Creating your own profile below).
Once a profile exists under ~/.config/ccx/profiles/, apply it to a project:
# scaffold a profile, then edit ~/.config/ccx/profiles/java/profile.yaml
ccx profiles new java
# apply it to a project (auto-enables any profiles it extends)
ccx profiles enable java --project-dir ~/my-project
# check what was applied
ccx status --project-dir ~/my-project
# launch the interactive dashboard
ccx tui --project-dir ~/my-project
ccx ships no profiles in the binary โ author your own under
~/.config/ccx/profiles/ โ one directory per profile. Scaffold one with:
ccx profiles new my-profile
# edit the generated ~/.config/ccx/profiles/my-profile/profile.yaml
~/.config/ccx/
โโโ profiles/
โ โโโ my-profile/
โ โโโ profile.yaml # the profile definition (see below)
โ โโโ rules/ # *.md rule files installed into .claude/rules/
โ โ โโโ no-empty-catch.md
โ โโโ claudemd/ # fragments for the CLAUDE.md block (see claudeMd.fragments)
โ โ โโโ java.md
โ โโโ commands/ # *.md command files
โ โโโ ship.md
โโโ claudemd/ # global fragments, shared across all profiles
โโโ company-style.md
profile.yamlA profile is a named bundle of plugins, rules, permissions, CLAUDE.md fragments, environment variables, and ignore patterns. Every field is optional.
metadata:
name: my-profile
description: "Java + Quarkus working set"
# inherit from other profiles; merged depth-first
extends:
- base
plugins:
enable:
- java@my-marketplace
permissions:
allow:
- "Bash(mvn *)"
deny:
- "Bash(rm -rf *)"
claudeMd:
fragments: # omit the key to inject every *.md in claudemd/
- java # resolves to claudemd/java.md
env:
ENABLE_LSP_TOOL: "1"
ignore:
- "target/"
Rule and claudemd fragments are plain markdown. Rule files are auto-discovered:
every *.md in a profile's rules/ directory is applied โ there is no key for
them in profile.yaml. Example
~/.config/ccx/profiles/my-profile/claudemd/java.md:
# Java conventions
- Records over POJOs, sealed classes, pattern matching
- SLF4J for logging โ never System.out
- Constructor injection, never field injection
claude-md addFragments that aren't tied to a single profile live in
~/.config/ccx/claudemd/. Create one and reference it from a project:
# create a global fragment
ccx config claudemd new company-style
# reference it from the current project's .claude/CLAUDE.md
ccx claude-md add company-style
claude-md add writes an absolute @<path> line into the ccx-managed block of
.claude/CLAUDE.md, so Claude Code picks up the fragment for that project.
Profiles are named bundles of plugins, fragments, rules, and permissions. When you enable a profile, ccx:
.claude/settings.json.claude/rules/โฆ block in CLAUDE.md.ccx/context.jsonThe snapshot enables drift detection: if you manually remove a plugin or rule file, profiles status will show ALTERED. Use profiles reinstall to bring the profile back to its declared state.
ccx tui [--project-dir .]
Interactive 5-tab dashboard (Overview, Profiles, Plugins, MCPs, CLAUDE.md). Requires a real TTY.
mvn verify
# Install GraalVM 25 with native-image
mvn package -Pnative
./target/ccx --help
Releases are created by pushing a v* tag. The CI builds a Linux x86_64 native binary and publishes a GitHub Release via JReleaser.
git tag v0.1.0
git push origin v0.1.0
How a build becomes an installed binary, end to end.
1. Build โ mvn clean package -Pnative produces target/ccx, a
self-contained Linux x86_64 native executable (no JVM required at runtime).
2. Release โ the release Maven profile runs JReleaser, which publishes the
native binary to GitHub Releases on the
aneveux/ccx repository with a conventional-commits changelog. The release is cut
by pushing a v* tag (see Release above); CI runs the native build and
the JReleaser publish step.
3. Install โ install.sh (the curl โฆ | bash one-liner above) resolves the
latest release tag, downloads the ccx binary and its checksums_sha256.txt
sidecar, verifies the SHA-256 checksum (fail-closed: aborts on a missing or
mismatched checksum), and installs the binary to ~/.local/bin/ccx. Override the
target with CCX_INSTALL_DIR; bypass verification (not recommended) with
CCX_SKIP_CHECKSUM=1.
Documented limits (current):
linux-x86_64 native binary; install.sh fetches only that binary.pom.xml declares a single linux-x86_64 JReleaser artifact and no
packagers. Adding them means authoring the packager config and a macOS native
build job in release.yml from scratch.๐ฟ CLI + TUI for fine-grained Claude Code config per project: Plugins, CLAUDE.md fragments, MCP servers, skills, rules & reusable profiles. No more hand-editing settings.json. Built on Quarkus + Picoc
Overview
๐ฟ CLI + TUI for fine-grained Claude Code config per project: Plugins, CLAUDE.md fragments, MCP servers, skills, rules & reusable profiles. No more hand-editing settings.json. Built on Quarkus + Picocli, shipped as a GraalVM native binary. ๐
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.
Ccx runs locally over stdio.
Last checked 2026-10-28. ๐ฟ CLI + TUI for fine-grained Claude Code config per project: Plugins, CLAUDE.md fragments, MCP servers, skills, rules & reusable profiles. No more hand-editing settings.json. Built on Quarkus + Picocli, shipped as a GraalVM native binary. ๐