gglint
Health Pass
- License — License: Apache-2.0
- Description — Repository has a description
- Active repo — Last push 0 days ago
- Community trust — 14 GitHub stars
Code Fail
- rm -rf — Recursive force deletion command in scripts/action.sh
Permissions Pass
- Permissions — No dangerous permissions requested
No AI report is available for this listing yet.
Keeps the MCP servers of Claude Code, Codex, Cursor, Gemini CLI and other coding agents in sync, and secrets out of their config files
gglint
Keep every coding agent in your repository in sync, and keep secrets out of their config
files.
Claude Code, Codex, Cursor, Gemini CLI, Copilot CLI and nine other coding agents are each set
up by their own files in a repository (see Supported agents). gglint
checks those files for two problems:
- MCP servers that drift apart. Each agent reads MCP servers from its own config file, in
its own format. In a repository set up for more than one of them, a server is added to.mcp.jsonbut not to.cursor/mcp.json, a version is pinned in one file and not the
other, or an agent has no MCP config at all.gglint mcpfinds every difference and fixes
it, written in each agent's own format. - Secrets written into agent files. Approving a command in Claude Code saves it, keys and
all, in.claude/settings.local.json, and tokens get pasted into.mcp.json,.codex/config.tomlandCLAUDE.md.gglint secretsfinds them, replaces the ones it can
with environment variables, and stops the agents' personal files from being committed.
The terminal shows gglint mcp on a repository whose agents have drifted apart. Click it to
open it on its own, then hover over a server, an agent, a cell or a problem to see what
gglint found there and what --fix does about it. The same details are in this table, on
hover:
| Server | Claude Code | Codex | Cursor | OpenCode |
|---|---|---|---|---|
github | ✓ | ✗ | ✗ | ✗ |
playwright | ✓ | ✗ | ≠ | ✗ |
linear | ✗ | ✗ | ✓ | ✗ |
| Command | What it does |
|---|---|
gglint mcp |
Compares the MCP servers of every coding agent, and fixes the differences. |
gglint secrets |
Finds credentials written out in agent config and instruction files, and replaces them with environment variables. |
| GitHub Action | Runs both on every pull request: annotations on the diff, a comment, and Code scanning. It only reports. |
gglint hook |
Runs the secrets check before every commit, through husky, git, pre-commit, lefthook or lint-staged. |
- One view of every agent. A table shows which agent gets which server, and how each
one differs. - One fix.
--fixadds the missing servers and config files and starts each server the
same way in every agent. It never removes a server, and keeps your comments and formatting. - Each agent's own format. A server is translated between JSON and TOML, between each
agent's syntax for environment variables, and between local and remote server types. - Secrets in the forms they leak in. Tokens in known formats, passwords in database URLs,
keys in the commands Claude Code saves as allowed, and values under names such aspasswordorAuthorization. A secret's value is never printed. - Personal files stay personal. Committing
.claude/settings.local.json,CLAUDE.local.mdor an agent's login file fails the check, whatever is in it. - Fast and read-only by default. gglint reads a few files at fixed paths and typically
finishes in under a millisecond. It never starts a server or downloads anything. - Built for CI. It exits with status 1 when it finds a problem, prints annotations for a
pull request or a SARIF log, and runs as a GitHub Action.
In November 2026 we checked the 258 most-starred GitHub repositories set up for two or more
of Claude Code, Codex, Cursor and OpenCode. Of the 179 that configure MCP servers, 128 (72%)
had at least one of the problems gglint reports. Among the 166 active repositories with 30 or
more stars that set up a newer agent, such as Gemini CLI, Kiro or Junie, 83 of the 162 with
MCP servers (51%) had at least one problem.
The same month we ran gglint secrets over 441 public repositories set up for coding agents:
21 had committed .claude/settings.local.json, and 5 had 7 secrets that look real in their
agent files, 2 of them inside commands saved in .claude/settings.json. Across all of public
GitHub, GitGuardian counted about 31,000 secrets in .claude/settings.local.json files
(report).
Quick start
gglint runs with uvx, which comes with uv. If uvx isn't on
your machine, install uv with its
installation guide first.
From the root of a repository, run both checks:
uvx gglint mcp
uvx gglint secrets
Each reports what it finds. To fix what it can, run each one again with --fix, thengit diff to see what changed. uvx downloads gglint the first time and reuses it
afterwards; there's nothing else to install. It works on Linux, macOS and Windows.
To check every pull request for secrets, add this workflow as.github/workflows/agent-secrets.yml (see GitHub Action for the options):
name: Agent secrets
on:
pull_request:
permissions:
contents: read
jobs:
gglint:
name: gglint secrets
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: corridor/gglint@v1
with:
command: secrets
comment: "false"
Usage
uvx gglint mcp [--fix] [--source AGENT] [--format FORMAT] [PATH]
uvx gglint mcp --servers [PATH]
uvx gglint secrets [--fix] [--staged] [--format FORMAT] [PATH | FILE...]
uvx gglint hook [install|print] [--tool NAME] [--with-mcp] [PATH]
The options below are for gglint mcp; secrets andhook describe their own.
| Option | Effect |
|---|---|
| (none) | Report every problem and draw each server in each agent. |
--fix |
Add missing servers and config files, start each server the same way, then report what's left. |
--source AGENT |
Take each server's setup from AGENT where it has the server. AGENT is a name from the --source column of Supported agents, such as claude-code or gemini-cli. |
--format FORMAT |
table (the default), lines, github, sarif or markdown. See Output formats. |
--servers |
List every configured server, file by file, without comparing them. |
PATH |
The repository's root. Defaults to the current directory. |
| Exit status | Meaning |
|---|---|
0 |
Every agent gets the same servers, set up the same way. |
1 |
gglint found a problem, one is left after --fix, or there are no MCP config files. |
gglint secrets exits with status 1 when it finds a problem, and 0 when it finds none or
only warnings, such as a secret in a file git ignores.
Colours are used when standard output is a terminal and NO_COLOR isn't set. The summary
line, with counts and timing, goes to standard error.
Finding secrets
gglint secrets finds credentials written out in the files that configure your coding
agents: their MCP config files, settings, and instruction files such as CLAUDE.md. These
files are committed, so a token pasted into .mcp.json ends up in git history. It also stops
the agents' personal files, such as .claude/settings.local.json, from being committed at all.
uvx gglint secrets # report every secret
uvx gglint secrets --fix # replace each with a reference to an environment variable
uvx gglint secrets --staged # only what's staged in git: the copy the commit gets
uvx gglint secrets FILE... # only these, where they're agent files, as a hook passes them
| Rule | Reported when |
|---|---|
inline-secret |
Text has the format of a known credential: GitHub, GitLab, Anthropic, Slack, Stripe, Google and npm tokens, AWS access key IDs, API keys starting with sk-, and private key blocks. |
inline-credential |
A JSON or TOML value under a name such as token, password, api_key or Authorization is written out instead of being a reference to an environment variable; a password is written into a URL (postgresql://admin:secret@db/app); or a command carries one, as a command Claude Code saves as allowed does: a header (curl -H "Authorization: Bearer …"), a variable set for the command (PGPASSWORD=… psql) or an option (--token …, sshpass -p …, mysql -p…). |
local-file |
An agent file meant for one person's machine is in git: .claude/settings.local.json, where Claude Code saves the commands you allow, secrets and all, CLAUDE.local.md, .claude/.credentials.json or .codex/auth.json. Whatever it holds, so a secret no pattern recognises is stopped too. It's a warning while the file is on disk and git doesn't ignore it yet. |
Placeholders (your-token-here, ghp_xxxx…), references (${GITHUB_TOKEN}) and values that
name a variable (bearer_token_env_var = "GITHUB_TOKEN") aren't reported. A secret's value is
never printed: gglint shows its kind, the name it's under, and where it is. A secret in a file
git ignores is a warning, since it isn't committed; only errors fail.
--fix writes the reference in the agent's own syntax, such as Bearer ${env:GITHUB_TOKEN}
in Cursor, and keeps everything else in the file as it was. An agent with no way to refer to
an environment variable, such as Codex in a http_headers table, is reported and left alone,
and so is a secret in a command: take it out of the command, or remove the command with/permissions in Claude Code. --fix also adds a personal agent file to .gitignore; one
that's already in git needs git rm --cached too. A secret that was ever committed is in git
history: rotate it.
Before every commit
gglint hook runs gglint secrets --staged before each commit, so a secret never gets
committed in the first place. It uses the tool your repository already has:
| Tool | What uvx gglint hook does |
|---|---|
| husky | Adds the command to .husky/pre-commit, keeping what's there. |
| git | Adds it to git's pre-commit hook, wherever core.hooksPath puts it. |
| pre-commit | Prints the lines for .pre-commit-config.yaml. |
| lefthook | Prints the lines for lefthook.yml. |
| lint-staged | Prints the lines for package.json. |
--tool NAME picks one instead of detecting it, --with-mcp adds the MCP check, andgglint hook print only prints. Running it twice changes nothing. The hooks runuvx gglint@<version>, pinned to the version that wrote them, so uv has to be installed.
With the pre-commit framework, gglint is also a source of hooks:
# .pre-commit-config.yaml
repos:
- repo: https://github.com/corridor/gglint
rev: v0.4.0
hooks:
- id: gglint-secrets
- id: gglint-mcp # optional: the MCP servers of every agent match
What gglint checks
| Rule | Reported when | Fixed by |
|---|---|---|
missing-server |
A server in one agent's config file is missing from another agent's. | --fix |
missing-config |
An agent has its own directory but no MCP config file, while other agents have servers. | --fix |
different-server |
The same server runs another version or has other arguments. | --fix |
| The same server runs another program or URL, has other environment variables or headers, or is turned off in one agent. | Reported only | |
renamed-server |
The same server has a different name in some agents. | Reported only |
--fix makes the command lines match, since the same server should normally start the same
way everywhere. The other differences can be deliberate, such as each agent setting its own
environment variables, so gglint reports them and leaves them to you.
Matching servers. Servers are matched by name, then by what they run, so a server named
differently in one agent is still recognised as the same server. The way a package is
launched doesn't count as a difference:
npx -y pkg,npx --yes pkg@latest,pnpm dlx pkg,yarn dlx pkg,bunx pkgandbun x pkgall run the npm packagepkg.uvx pkg,uv tool run pkgandpipx run pkgall run the PyPI packagepkg.npx mcp-remote <url>reaches the remote server at<url>.- No version and
latestboth mean the newest version. ${KEY}in Claude Code,${env:KEY}in Cursor and$KEYin Gemini CLI refer to the same
environment variable.
Environment variables and headers are compared by name only, since their values can be
secrets.
Supported agents
| Agent | --source |
MCP config file | Agent directory | Format |
|---|---|---|---|---|
| Claude Code | claude-code |
.mcp.json |
.claude/ |
JSON, mcpServers |
| Codex | codex |
.codex/config.toml |
.codex/ |
TOML, [mcp_servers.<name>] |
| Cursor | cursor |
.cursor/mcp.json |
.cursor/ |
JSON, mcpServers |
| OpenCode | opencode |
opencode.json, opencode.jsonc |
.opencode/ |
JSON with comments, mcp.servers or mcp |
| Antigravity | antigravity |
.agents/mcp_config.json |
none | JSON, mcpServers |
| Copilot CLI | copilot-cli |
.github/mcp.json, or .mcp.json |
none | JSON, mcpServers or servers at the top |
| Factory Droid | droid |
.factory/mcp.json |
.factory/ |
JSON, mcpServers |
| Gemini CLI | gemini-cli |
.gemini/settings.json |
none | JSON, mcpServers among other settings |
| Junie | junie |
.junie/mcp/mcp.json |
.junie/ |
JSON, mcpServers |
| Kimi Code | kimi-code |
.kimi-code/mcp.json |
.kimi-code/ |
JSON, mcpServers |
| Kiro | kiro |
.kiro/settings/mcp.json |
.kiro/ |
JSON, mcpServers |
| Qoder | qoder |
.qoder/settings.json, .mcp.json |
.qoder/ |
JSON, mcpServers among other settings |
| Qwen Code | qwen-code |
.qwen/settings.json |
.qwen/ |
JSON, mcpServers among other settings |
| Trae | trae |
.trae/mcp.json |
.trae/ |
JSON, mcpServers |
gglint compares the agents that have an MCP config file or their own directory at the
repository's root. A CLAUDE.md, .cursorrules or AGENTS.md file on its own doesn't
count, because it doesn't show that the agent is set up in the repository. Antigravity,
Copilot CLI and Gemini CLI count only once they have their config file: many repositories
have an .agents/, .github/ or .gemini/ directory for other reasons, such as skills,
workflows or Gemini Code Assist's reviews.
Qoder reads Claude Code's .mcp.json as well as its own file: a server there counts as
Qoder's, and a server missing from both is added to .mcp.json only.
Copilot CLI reads .mcp.json instead of .github/mcp.json whenever .mcp.json exists, so it
gets the same servers as Claude Code, and gglint warns that .github/mcp.json goes unread.--fix creates a .mcp.json only if every server in .github/mcp.json is written to it.
Copilot also skips a .github/mcp.json that lists no servers under mcpServers or at its
top, such as one with VS Code's servers: gglint warns about it and leaves it alone.
How fixing works
Every server is copied from the first config file where it's turned on, in the order of the
table in Supported agents. To make one agent the source of truth
instead, name it with --source: uvx gglint mcp --fix --source codex takes each server from
Codex wherever Codex has it turned on, and from the first agent otherwise. --fix never
removes a server.
- A missing server is added to each config file that lacks it.
- An agent with its own directory but no config file gets one, with every server that is
turned on in the other agents. - A server that runs another version of the same program, or the same program with other
arguments, gets the command and arguments of that first config file. Its environment
variables, headers, on/off state and keys only one agent has, such as Codex'scwd, are
kept. Review the result withgit diff: a difference such as a runtime chosen per agent,
or a path that starts with Cursor's${workspaceFolder}, may have been deliberate. - JSON is edited with jsonc-parser and TOML with
toml_edit, so comments and formatting are kept. - Running
--fixa second time changes nothing. - A file excluded by
.gitignoreis still updated, and markedgitignoredin the output,
because the change won't be committed.
References to environment variables are rewritten in each agent's syntax, in values and in
command lines:
| Agent | Environment variable KEY |
|---|---|
| Claude Code | ${KEY} |
| Cursor | ${env:KEY} |
| OpenCode | {env:KEY} |
| Gemini CLI, Qoder, Qwen Code | $KEY or ${KEY}, written ${KEY} |
| Kiro, Factory Droid | ${KEY}, in environment variables and headers only |
| Codex | env_vars = ["KEY"], env_http_headers, or bearer_token_env_var for Authorization: Bearer |
| Kimi Code | bearerTokenEnvVar for Authorization: Bearer |
| Antigravity, Copilot CLI, Junie, Trae | None documented, so a server that reads the environment isn't copied to them |
Each server is written the way its agent expects:
- Remote servers get
"type": "http", or"sse"for a URL ending in/sse, in Claude Code,
Copilot CLI, Factory Droid and Qoder. - Gemini CLI and Qwen Code get the URL as
httpUrl, or asurlfor SSE. - Kimi Code gets
"transport": "sse"for SSE, and a bearer token read from the environment
asbearerTokenEnvVar. - Antigravity gets the URL as
serverUrl. It reaches remote servers over streamable HTTP
only, so a server reached over SSE isn't added. - Copilot CLI's local servers get
"type": "local". - OpenCode servers get
"type": "local"or"remote", with the command and its arguments in
one list.
A server is skipped, and listed under Not added:, when its setup can't be expressed in the
other agent's format: for example Claude Code's ${KEY:-default}, Cursor's${workspaceFolder}, an environment variable inside a command line, which Codex, Kiro and
Factory Droid don't expand, or any environment variable for an agent whose docs don't say how
to refer to one.
Example
$ uvx gglint mcp --fix
Changed 4 files:
.mcp.json added linear
.codex/config.toml added github, playwright, linear
.cursor/mcp.json added github; updated playwright
opencode.json (new) added github, playwright, linear
Review the changes with `git diff`.
The same github server, written for Codex and Cursor:
# .codex/config.toml
+[mcp_servers.github]
+url = "https://api.githubcopilot.com/mcp/"
+bearer_token_env_var = "GITHUB_TOKEN"
# .cursor/mcp.json
+ "github": {
+ "url": "https://api.githubcopilot.com/mcp/",
+ "headers": {
+ "Authorization": "Bearer ${env:GITHUB_TOKEN}"
+ }
+ }
Cursor's playwright now starts as in Claude Code:
# .cursor/mcp.json
- "args": ["-y", "@playwright/mcp@latest"]
+ "args": ["-y", "@playwright/[email protected]", "--headless"]
Output formats
--format lines prints one problem per line: where it is, the rule, and a description, with
the server's other locations indented below it.
$ uvx gglint mcp --format lines
./.mcp.json:3:5 missing-server `github` is set up for Claude Code but not for Codex (.codex/config.toml) or Cursor (.cursor/mcp.json)
./.mcp.json:8:5 different-server `playwright` runs different versions of the npm package `@playwright/mcp`: 0.0.78 in Claude Code; the newest in Cursor
also at ./.cursor/mcp.json:3:5
./.mcp.json:3:5 missing-config OpenCode has a .opencode directory but no opencode.json, so it gets none of the 3 MCP servers set up for Claude Code and Cursor
--servers lists every server as it's written. Environment variables and headers are shown
by name, never by value.
$ uvx gglint mcp --servers
./.mcp.json:3:5 claude-code github https://api.githubcopilot.com/mcp/ (headers=[Authorization])
./.mcp.json:8:5 claude-code playwright npx -y @playwright/[email protected] --headless
./.cursor/mcp.json:3:5 cursor playwright npx -y @playwright/mcp@latest
./.cursor/mcp.json:7:5 cursor linear https://mcp.linear.app/sse
Formats for CI
--format takes the same five values for mcp and secrets:
| Format | Prints |
|---|---|
table |
The default: each command's own drawing, for reading in a terminal. |
lines |
One line per problem. |
github |
Workflow commands, so GitHub shows each problem as an annotation on its line in a pull request's Files changed. |
sarif |
A SARIF 2.1.0 log, for GitHub's Security, Code scanning tab. Each command is its own category. |
markdown |
A section for a pull request comment: the problems as a table, and for mcp a table of servers by agent. |
The summary line still goes to standard error, so standard output holds only the report.
GitHub Action
The gglint action checks every pull request, and only reports: it never changes a file.
# .github/workflows/gglint.yml
name: gglint
on: [pull_request]
permissions:
contents: read
pull-requests: write # for the comment
jobs:
gglint:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: corridor/gglint@v1
It does three things with what gglint finds:
- Annotations. Each problem appears on its line in the pull request's Files changed.
- One comment. The problems, and a table of which agent gets which MCP server, in a single
comment that's updated on every push, and left alone when a pull request has no problems.
Posting needspull-requests: write; a pull request from a fork can't post, and still gets
the annotations and the failing check. - Code scanning (optional). With
sarif: true, the findings also go to Security, Code
scanning, where they can be tracked and dismissed. That needssecurity-events: write, and
Code scanning enabled on a private repository.
| Input | Default | Meaning |
|---|---|---|
command |
all |
secrets, mcp or all. |
path |
. |
The repository's root, for a repository checked out elsewhere. |
version |
the one @v1 was released with |
The gglint version to run, from PyPI. Pin it for repeatable runs. |
fail-on-problems |
true |
Set to false to report without failing the check. |
comment |
true |
Post the pull request comment. |
sarif |
false |
Upload to Code scanning. |
A repository with no MCP config files has nothing to compare, so mcp is skipped with a
notice. The action runs gglint with uv and doesn't start a
server or fetch anything else.
To run gglint without the action:
- uses: astral-sh/setup-uv@v7
- run: uvx [email protected] mcp --format github
- run: uvx [email protected] secrets --format github
Security
- Read-only by default. Without
--fix, gglint reads files and writes nothing. - Nothing is executed or fetched. MCP servers aren't started, packages aren't resolved,
and environment variables aren't expanded. It's safe to run on an untrusted repository. - Secrets stay out of the output. Environment variables and headers are printed by name
only, andgglint secretsshows a secret's kind, the name it's under and where it is, never
its value. - One external program: git. gglint runs
git check-ignoreto mark files your.gitignoreexcludes (inmcp --fixand insecrets),git ls-filesto see whether a
personal agent file is in git,git diff --cachedandgit showto read what's staged forsecrets --staged, andgit rev-parse --git-path hooksforgglint hook. - Nothing is overwritten by
hook. An existing hook script is extended, once.
Limitations
- Servers added by Claude Code plugins, enabled in
.claude/settings.json, aren't read. A
server provided by a plugin can be reported as missing from Claude Code. - User-level settings such as
~/.claude.jsonor~/.codex/config.tomlaren't read. - Only config files at the repository's root are read, so each package of a monorepo is
checked separately. - VS Code and GitHub Copilot in VS Code (
.vscode/mcp.json), Zed, Kilo Code, Crush, Amp,
Continue and Mistral Vibe aren't supported yet
(#10). - Gemini CLI loads only the servers listed in
mcp.allowed, when its settings have that
list, and never those inmcp.excluded; gglint reports the servers these lists leave out
as turned off.--fixdoesn't edit the lists, so a server it adds whilemcp.allowedis
set stays off until you add it there. gglint secretsreads a file line by line. It finds a value under a name such astoken
in JSON and TOML files, and in every agent file the credential formats it knows, passwords
in URLs and secrets in commands. It misses a password made of one kind of letters
("hunter") or shorter than 8 characters, and in a command one with no digit or symbol
(app-reader), as commands and the text around them are full of words and names. It doesn't
read.envfiles or other source, and doesn't search git history: a secret that was ever
committed has to be rotated.gglint secrets --fixcan't change a value for an agent that has no way to refer to an
environment variable, such as Codex inhttp_headers; it reports it and says what to use
instead.- Windsurf, Cline and Goose read MCP servers only from the user's home directory, so there's
nothing in a repository to compare. - Codex, Copilot CLI, Gemini CLI, Qoder and Qwen Code load a repository's MCP servers only
once you trust the project or approve its servers. Trae reads.trae/mcp.jsononce project
MCP is turned on in its settings.
Development
gglint is written in Rust. With a Rust toolchain 1.88 or later, run these
three commands in order before each commit; CI runs the same checks:
cargo fmt
cargo clippy --all-targets -- --deny warnings
cargo test
tests/corpus.rs runs --fix against a directory of real repositories and checks that no
server is removed, that no environment variable, header or on/off state changes, that a
config file is created only in an agent's own directory, that no file becomes unreadable,
that the number of missing servers and differences never grows, and that a second run changes
nothing:
GGLINT_CORPUS=path/to/clones cargo test --release --test corpus -- --ignored --nocapture
The code lives in src/.harness/ does the MCP check:agents.rs describes each agent in one table, mcp.rs reads each agent's config,compare.rs finds the problems, and fix.rs writes the fixes. Supporting another agent
starts with a row in agents.rs. report.rs is what every check prints through,secrets.rs finds secrets and replaces them, and hook.rs sets up the pre-commit hooks.
Releasing
- Update
versioninCargo.tomland add the release toCHANGELOG.md. - Merge to
main. - Publish a GitHub release tagged
v<version>, for examplev0.4.0. - Move the
v1tag to the release's commit, souses: corridor/gglint@v1runs it:git tag -f v1 v<version> && git push -f origin v1.
The release workflow
builds and tests every wheel, publishes them to PyPI, and attaches them to the release.
License
gglint is licensed under the Apache License 2.0.
The licenses of the libraries compiled into it are listed in
THIRD_PARTY_LICENSES.
Reviews (0)
Sign in to leave a review.
Leave a reviewNo results found