Skip to main content
Glama
deenesjakoruzh
wedo911

secretscan

by wedo911
OverviewSchemaSourceRelated ServersDiscussionsAdmin
TypeScript
Remote

secretscan-mcp-server

Glama score

An MCP server that scans a diff, a file's contents, or a pasted snippet for accidentally-committed secrets -- so any MCP-compatible agent can self-check its own changes before committing, opening a PR, or pasting a log excerpt anywhere. Fully local: no API key, no network call, no dependency beyond the MCP SDK and Zod.

Why

A leaked credential is one of the most common real-world causes of account and infrastructure compromise, and one of the easiest mistakes to make in a large diff -- a debug console.log with a real API key, a config file committed by accident, a .env pasted into a chat while asking for help. An agent that's about to commit, push, or share text is well positioned to catch this before it happens, if it has a cheap way to check.

Related MCP server: opzyai

Tool

scan_for_secrets

Scans text against a fixed set of provider-format signatures plus a generic, entropy-gated heuristic:

Detector

Catches

aws_access_key_id

AWS access key IDs (AKIA...)

aws_secret_access_key

AWS secret keys, when contextually labeled

github_personal_access_token / github_fine_grained_token

GitHub PATs (ghp_..., github_pat_...)

slack_token

Slack tokens (xoxb-..., etc.)

stripe_live_key / stripe_test_key

Stripe secret/publishable keys

google_api_key

Google API keys (AIza...)

npm_token

npm publish tokens (npm_...)

private_key_block

PEM private key blocks

jwt

JSON Web Tokens

generic_assigned_secret

anything assigned to a secret-sounding variable name (api_key, password, token, ...) whose value has high enough Shannon entropy to look random rather than a placeholder like "changeme"

Findings are always redacted -- AKIAIOSFODNN7EXAMPLE is reported as AKIA************MPLE (20 chars), never in full. The tool's own output is therefore safe to log or display without further propagating whatever it found.

This is a fixed-pattern + heuristic scan, not exhaustive. A clean result means "no known pattern matched," not "definitely safe" -- the in-app output says so explicitly.

Install and configure

git clone https://github.com/wedo911/secretscan-mcp-server.git
cd secretscan-mcp-server
npm install
npm run build

Add it to your MCP client's config (e.g. claude_desktop_config.json, or a project's .mcp.json for Claude Code):

{
  "mcpServers": {
    "secretscan": {
      "command": "node",
      "args": ["/absolute/path/to/secretscan-mcp-server/dist/index.js"]
    }
  }
}

Run the tests

npm run build
node --test tests/entropy.test.mjs tests/detectors.test.mjs

24 tests, including one for every named detector, the placeholder- and low-entropy-filtering behavior of the generic detector, and an explicit check that redacted output never contains the full secret value.

Try it without a client

npx @modelcontextprotocol/inspector --cli node dist/index.js \
  --method tools/call --tool-name scan_for_secrets \
  --tool-arg text='aws_access_key_id = AKIAIOSFODNN7EXAMPLE'

(That's AWS's own publicly documented example key -- not a real credential.)

License

MIT — see LICENSE.

Available Tools

1 tool
scan_for_secretsScan Text for Leaked SecretsA
Read-onlyIdempotent

Scan text (a git diff, a file's contents, a pasted snippet) for accidentally-committed secrets: cloud provider keys (AWS, Google), platform tokens (GitHub, Slack, npm), payment keys (Stripe), private key blocks, JWTs, and a generic entropy-gated check for anything assigned to a secret-sounding variable name. Use this before committing, opening a PR, or pasting logs/config anywhere -- a committed secret is one of the most common real-world causes of account and infrastructure compromise, and is easy to miss in a large diff.

Findings are always redacted (first/last few characters only) -- this tool never returns a full secret value, so its own output is safe to log or display.

Args:

  • text (string, 1-200000 chars): the text to scan.

Returns: For JSON format: { "found": boolean, "riskLevel": "none" | "medium" | "high" | "critical", "findings": [ { "detector": string, "category": string, "severity": "low"|"medium"|"high"|"critical", "line": number, "column": number, "redacted": string } ] }

Examples:

  • Use when: about to run "git commit" or "git push" -- scan the staged diff first

  • Use when: about to paste a config file, log excerpt, or error message into a chat or issue tracker

  • Don't use when: you need certainty nothing sensitive is present -- this is a fixed-pattern + heuristic scan, not exhaustive; a clean result means "no known pattern matched," not "definitely safe"

Error Handling:

  • Returns an error if text is empty or exceeds 200000 characters.

ParametersJSON Schema
NameRequiredDescriptionDefault
textYesThe text to scan -- a git diff, a file's contents, or any pasted snippet.

TDQS

A4.7/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds critical behavioral context beyond this: findings are always redacted to the first/last few characters, output is safe to log, the scan is not exhaustive, and empty/oversized inputs produce errors. This meaningfully exceeds what annotations convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The definition is well-structured with clear sections (description, args, returns, examples, error handling), front-loads the core purpose and usage guidance, and every section carries useful information. Length is justified by the tool's security-critical nature and the need to explain redaction and limitations.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description fully specifies the return payload structure including found, riskLevel, and findings fields. It also covers error handling, length constraints, and usage examples. For a single-parameter tool with strong annotations, this is complete and leaves no critical gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the input schema already describes text as 'a git diff, a file's contents, or any pasted snippet' with length constraints. The description repeats these details, adding little new semantic meaning beyond the schema, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource ('Scan text ... for accidentally-committed secrets') and enumerates the exact detector categories (cloud keys, platform tokens, payment keys, private key blocks, JWTs, entropy-gated checks). This is precise and unambiguous even without sibling tools to differentiate from.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit when-to-use scenarios ('before committing, opening a PR, or pasting logs/config anywhere') and an explicit don't-use case ('you need certainty nothing sensitive is present'). It also honestly frames the tool's limits as a fixed-pattern + heuristic scan, giving clear decision guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 1 tool updatev1.0.0
    • First observedscan_for_secrets
Deploy Server
One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.6/5.0

Scored across 1 tool

Disambiguation5/5

Only one tool exists, so there is zero ambiguity or risk of misselection. The tool's purpose is clearly singular.

Naming Consistency5/5

The single tool uses a consistent verb_noun pattern ('scan_for_secrets'), which is clear and predictable.

Tool Count3/5

With only one tool, the server feels thin, but for a narrow purpose like scanning text for secrets, a single comprehensive tool is reasonable. It borders on minimal but works.

Completeness5/5

The tool covers the full scanner domain: it detects a wide variety of secrets, provides redacted output, and handles error cases. There are no obvious missing operations for its stated purpose.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers

  • secret-scanner

    Baneado98
    A
    license
    A
    quality
    B
    maintenance
    Enables scanning diffs or code blobs for leaked secrets, returning a verdict with severity and masked findings, all processed locally with no data sent externally.
    1
    MIT

  • opzyai

    thfothijn
    A
    license
    Not graded
    quality
    B
    maintenance
    Local-first security check for AI coding agents — finds hardcoded secrets, exposed .env files, git-history leaks and vulnerable dependencies (OSV), entirely on your machine. Ask your agent "is this safe to ship?" and get a Launch Readiness score with a fix for every finding.
    MIT

  • netallion-mcp-lite

    netallion
    A
    license
    Not graded
    quality
    A
    maintenance
    Scans text and files for common secrets (AWS, GitHub, etc.) and redacts them to prevent credential leakage in AI-assisted development. Runs entirely locally with no telemetry.
    MIT