guardvibe
One-line summary: GuardVibe is a 100% local security MCP server that lets an AI coding agent scan code, dependencies, secrets, configs, data flows and auth coverage for vulnerabilities — and harden the prompts that generate that code.
Scan inline code / files / repos —
check_code,scan_file,check_project,scan_directoryreturn findings with severity, OWASP mapping and an A–F security score.Full audit in one call —
full_auditruns code (684 rules), secrets, dependency CVEs, config, taint and auth checks, returning PASS/FAIL/WARN + a deterministic hash.Fix and prove the fix —
fix_codereturns patches;secure_thisapplies only fixes that re-verify (rollback on regression);verify_fixconfirms a rule is resolved.Remediation loop —
remediation_planandverify_remediationenforce a section-by-section fix checklist after a failed audit.Shift-left on prompts —
secure_prompttriages a coding prompt (NO_MOD / LIGHT_MOD / HEAVY_MOD) and injects severity-ranked security requirements before code is written.Dependency & supply-chain checks —
scan_dependencies,check_dependencies(OSV CVEs, 309 CVE rules),check_package_health(typosquats),scan_hallucinated_packages(phantom/slopsquatted imports).Secrets detection —
scan_secretsandscan_secrets_history(git history, active vs. removed keys).Config & policy —
audit_config,scan_config_change(security downgrades),generate_policy(CSP/CORS/RLS),policy_check(.guardviberc).Dataflow / auth analysis —
analyze_dataflow,analyze_cross_file_dataflow(taint to sinks),auth_coverage(route protection map),repo_security_posture.Workflow & CI integration —
scan_staged,scan_changed_files,review_pr(diff-aware gating),export_sarif,compliance_report(SOC2/PCI-DSS/HIPAA/GDPR/ISO27001/EU AI Act).Agent host & command safety —
guardvibe_doctor,audit_mcp_config,scan_host_config(MCP hook injection, base-URL hijack),check_command(allow/ask/deny on shell commands).Optional LLM deep analysis —
deep_scanfor IDOR, business logic, race conditions and auth bypass (requires an API key; everything else runs offline).Guidance & tracking —
get_security_docs,explain_remediation,security_workflow,security_stats.
Provides security analysis for Clerk authentication, including auth coverage and secure configuration detection.
Provides security analysis for Drizzle ORM, including SQL injection detection and CVE version detection.
Provides security analysis for Express.js applications, including vulnerability scanning and best practices.
Provides security analysis for FastAPI applications, including vulnerability detection and secure coding patterns.
Integrates with GitHub Actions for CI/CD security scanning, including SARIF report generation and PR review annotations.
Provides security analysis for Hono applications, including CVE version detection and secure configuration.
Provides security analysis and remediation for Next.js applications, including auth coverage, config audit, and vulnerability scanning for App Router and Pages Router.
Integrates with pre-commit hooks to block insecure code before it reaches the repository.
Provides security analysis for Prisma ORM, including SQL injection detection and secure query patterns.
Provides security analysis for React applications, including XSS prevention and secure coding patterns.
Provides security analysis for Stripe integrations, including webhook signature verification, secrets detection, and secure coding patterns.
Provides security analysis for Supabase projects, including RLS policy generation, auth detection, and secret scanning.
Provides security analysis for tRPC applications, including vulnerability detection and CVE version intelligence.
GuardVibe
Security infrastructure your AI can't be. No matter how good your coding agent gets, it can't know the CVE published after its training cutoff, it can't deterministically guarantee the same check every run, it can't hold your whole repo in context, and it can't objectively review its own code. GuardVibe does all four — the deterministic, post-cutoff-current, whole-repo, author-independent verification layer for AI-written code.
🗓️ Knows what your AI doesn't. CVE rules refreshed daily from GHSA / OSV.dev / CISA KEV — GuardVibe flags vulnerable dependencies published after your model's training cutoff. (309 CVE rules,
npm run inteldaily triage.)🎯 Deterministic, not probabilistic. Same code = same result, every run (content-hashed). Your AI guesses; GuardVibe doesn't.
🗺️ Sees the whole repo. Cross-file taint + auth-coverage across every route — catches the unprotected endpoint your agent's narrow context missed.
🔍 An independent second pair of eyes. The thing that wrote the code can't review itself. GuardVibe is the outside checker on AI-written code — in the loop while your AI codes (real-time edit hook), not after.
⬅️ NEW: Starts before the first line of code. Every scanner on earth — including your agent reviewing itself — acts after the code exists.
secure_promptacts before: it analyzes the coding prompt itself, detects the stack and attack surfaces it implies, and embeds severity-ranked GuardVibe requirements into the prompt your AI executes. The vulnerability is prevented, not caught. Deterministic, zero LLM calls — and if the prompt is already secure, it passes through untouched.
The security MCP built for vibe coding. 684 security rules, 39 tools covering the entire AI-generated code journey — from the prompt itself to production deployment.
Works with Claude Code, Cursor, Gemini CLI, Codex, VS Code (Copilot), Windsurf, and any MCP-compatible coding agent.
Why a tool, when your AI is so good?
"More rules" was never the moat — a strong model already knows most security rules by heart. What it can't do is be deterministic, know the CVE published after its training cutoff, hold your whole repo in context, or objectively review the code it just wrote. Those four gaps are structural; they don't close as models improve. GuardVibe is the layer that fills them — running while your AI codes, not in a separate audit later. And since v3.19, it runs before your AI codes too: secure_prompt rewrites the task itself so the security requirements are in the prompt, not in the post-mortem.
Related MCP server: grippy-code-review
Why GuardVibe
Most security tools are built for enterprise security teams. GuardVibe is built for you — the developer using AI to build and ship web apps fast.
684 security rules, 39 tools purpose-built for the stacks AI agents generate
Zero setup friction —
npx guardvibeand you're scanningNo account required — runs 100% locally, no API keys, no cloud
Understands your stack — not generic SAST, but rules that know Next.js, Supabase, Stripe, Clerk, and the tools you actually use
CVE version intelligence — detects 309 known vulnerable package versions in package.json, refreshed every day from GHSA / OSV.dev / CISA KEV
AI agent & MCP security — detects MCP server vulnerabilities, tool-description prompt injection (OWASP MCP Top 10), model-controlled sandbox-disable flags, excessive AI permissions, indirect prompt injection
Auto-fix suggestions —
fix_codetool returns concrete patches and structured edits the AI agent can apply mechanically. Coverage: hardcoded credentials → env-var migration; public-prefix LLM keys (NEXT_PUBLIC_/VITE_/EXPO_PUBLIC_/REACT_APP_) → prefix removal; CORS wildcards → env allowlist;dangerouslyAllowBrowserflags → drop; sandbox bypass flags (unsafe/noSandbox/allowEval) → drop; agent loops → addmaxSteps; raw-HTML React props →<ReactMarkdown>; missing auth checks → insert auth guard; SQL injection → parameterized queries; missing rate limiters / CSRF / security headers → snippet templates.Pre-commit hook — block insecure code before it reaches your repo
CI/CD ready — GitHub Actions workflow with SARIF upload to Security tab
Agent-friendly output — JSON format for AI agents, Markdown for humans, SARIF for CI/CD
Plugin system — extend with community or premium rule packs
Taint analysis that knows sanitizers — dataflow stops at DOMPurify, escape functions and parameterized queries, so sanitized paths don't raise findings
One score for the whole project — code, dependencies, config, secrets, auth coverage and taint analysis all count toward it
What's new
v3.81 — Aedes MQTT broker crash, obsidian-sync-mcp DNS rebinding rules
v3.80 — Effect Schema ReDoS, Todoist MCP DNS rebinding, @augment-vir/node command injection, CodeWhale agent approval bypass rules
v3.79 — mcp-sanitizer SSRF and path bypass, mssql-mcp SQL injection, libp2p crypto and gossipsub DoS, install-artifact-from-github unverified native download rules
New CVE rules ship almost every day. Full history: CHANGELOG.md · Releases
How GuardVibe Compares
GuardVibe is purpose-built for the AI coding workflow. Traditional tools are excellent for enterprise CI/CD pipelines — GuardVibe fills a different gap.
Capability | GuardVibe | Traditional SAST | Dependency Scanners |
Runs inside AI agents (MCP) | Native | Not supported | Not supported |
Zero config setup |
| Account + config required | Built-in (limited) |
Vibecoding stack rules (Next.js, Supabase, Clerk, tRPC, Hono) | 100+ dedicated | Generic patterns | Not applicable |
AI/LLM security (prompt injection, MCP, tool abuse) | 68 rules | Experimental/None | None |
AI host security (CVE-2025-59536, CVE-2026-21852) |
| Not supported | Not supported |
Auto-fix suggestions for AI agents |
| CLI autofix | Not supported |
CVE version detection | 309 packages, refreshed daily | Extensive | Extensive |
Compliance mapping (SOC2, PCI-DSS, HIPAA) | Built-in | Paid tier | None |
SARIF CI/CD export | Yes | Yes | Limited |
Rule count | 684 (focused, 68 AI-native) | 5000+ (broad) | N/A |
When to use GuardVibe: You're building with AI agents and want security scanning integrated into your coding workflow — no dashboard, no account, no CI setup.
When to use traditional tools: You need deep AST analysis, enterprise dashboards, org-wide policy enforcement, or coverage across hundreds of languages.
Quick Start
Claude Code
npx guardvibe init claudeCreates .mcp.json MCP config (pinned to current version), .claude/settings.json auto-scan hooks, and CLAUDE.md security rules. Restart Claude Code after setup.
Cursor
npx guardvibe init cursorCreates .cursor/mcp.json and .cursorrules with security rules. Restart Cursor after setup.
Gemini CLI
npx guardvibe init geminiCreates ~/.gemini/settings.json MCP config and GEMINI.md security rules.
Codex (OpenAI)
codex mcp add guardvibe -- npx -y guardvibeVS Code (GitHub Copilot)
Create .vscode/mcp.json in your project:
{
"servers": {
"guardvibe": {
"command": "npx",
"args": ["-y", "guardvibe"]
}
}
}Note: VS Code uses
"servers", not"mcpServers".
Windsurf
Add to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"guardvibe": {
"command": "npx",
"args": ["-y", "guardvibe"]
}
}
}All platforms at once
npx guardvibe init all # Claude + Cursor + GeminiPre-commit hook
npx guardvibe hook install # Blocks commits with critical/high findings
npx guardvibe hook uninstall # Remove hookCI/CD (GitHub Actions)
npx guardvibe ci github # Generates .github/workflows/guardvibe.yml (SARIF scan)
npx guardvibe ci github --pr # + a diff-aware PR review workflow that posts inline commentsWhat GuardVibe Scans
Application Code
Next.js App Router, Server Actions, Server Components, React, Express, Hono, tRPC, GraphQL, FastAPI, Go
Authentication & Authorization
Clerk, Auth.js (NextAuth), Supabase Auth, OAuth/OIDC (state parameter, PKCE) — middleware checks, secret exposure, session handling, SSR cookie auth, admin method protection
Database & ORM
Supabase (RLS, anon vs service role), Prisma (raw query injection, CVEs), Drizzle (SQL injection — including CVE-2026-39356 identifier-injection), MikroORM (CVE-2026-44680 runtime-identifier injection), Kysely (CVE-2026-44635 JSON-path traversal), Turso/LibSQL (client exposure, SQL injection), Convex (auth bypass, internal function exposure)
Payments
Stripe (webhook signatures, replay protection, secret keys), Polar.sh, LemonSqueezy
Third-Party Services
Resend (email HTML injection), Upstash Redis, Pinecone, PostHog, Google Analytics (PII tracking), Uploadthing (auth, file type/size)
AI / LLM Security
Prompt injection detection, LLM output sinks, system prompt leaks, MCP server SSRF/path traversal/command injection, MCP tool description prompt-injection markers (OWASP MCP Top 10 alignment, VG1068), model-controlled sandbox-disable flags (dangerouslyDisableSandbox, VG1063), AI agent unrestricted shell/database access, dangerouslyAllowBrowser, missing maxTokens, agent loop without maxSteps, AI API key client exposure, indirect prompt injection via external data, RAG/vector poisoning, public-prefix LLM key leaks (NEXT_PUBLIC_*, VITE_*, EXPO_PUBLIC_*)
AI Host Security
guardvibe doctor — unified host hardening scanner detecting CVE-2025-59536 (hook injection via .claude/settings.json), CVE-2026-21852 (API key exfiltration via ANTHROPIC_BASE_URL override), MCP config audit, environment scanner, permission analysis. Supports Claude, Cursor, VS Code, Gemini, Windsurf. Host-specific remediation with platform-tailored fix steps.
OWASP API Security
BOLA/IDOR (Broken Object Level Authorization), mass assignment (spread request body, Object.assign), missing pagination, rate limiting, admin endpoint authorization, verbose error leaks
Modern Stack
Zod .passthrough() mass assignment, z.any() bypass, file upload validation, server-only import guard, webhook replay protection, CSP headers, unsafe-inline/unsafe-eval detection, cron endpoint auth
Mobile
React Native, Expo — AsyncStorage secrets, deep link token exposure, hardcoded API URLs, ATS configuration
Firebase
Firestore security rules, Firebase Admin SDK exposure, storage rules, custom token validation
CVE Version Intelligence (309 CVEs, refreshed daily)
Frameworks: Next.js (CVE-2024-34351, CVE-2024-46982, CVE-2025-29927, CVE-2026-23869, CVE-2026-44573 / 44574 / 44575 / 44578 / 44579 / 45109 May 2026 cluster), React + react-server-dom-* (CVE-2025-55182, CVE-2026-23870), Express, Hono pre-4.12.18 cluster, @vitejs/plugin-rsc, Strapi content-type-builder (CVE-2026-22599)
Auth: Clerk middleware bypass (GHSA-vqx2), Clerk has() org/billing/reverification bypass (GHSA-w24r), Clerk clerkFrontendApiProxy SSRF (CVE-2026-34076), NextAuth.js (2 CVEs), jsonwebtoken
ORMs / SQL: Drizzle SQL identifier injection (CVE-2026-39356) + Drizzle sql.raw interpolation (VG1073), MikroORM SQL injection (CVE-2026-44680), Prisma raw-query call-form, Kysely JSON-path traversal (CVE-2026-44635)
AI ecosystem: @anthropic-ai/sdk (CVE-2026-34451 + memory tool path escape), Vercel AI SDK file-type bypass (CVE-2025-48985), LangSmith untrusted prompt manifest (CVE-2026-45134), OpenClaude sandbox bypass (CVE-2026-42074), @nyariv/sandboxjs Function.caller escape (CVE-2026-43898)
HTTP / parsing: Axios pre-1.15.2 cluster (SSRF + prototype-pollution + DoS + CRLF) + axios proxy-auth redirect leak (VG1071), Hono setCookie attribute injection (VG1072, override pinned ^4.12.21), fast-uri path traversal + host confusion (CVE-2026-6321 / 6322), fast-xml-parser CDATA injection, xmldom CDATA, protobuf.js multi-CVE cluster, undici (2 CVEs), ws
Tools / supply chain: node-ipc protestware (VG1069), Miasma @redhat-cloud-services namespace compromise IOC (VG1074), Session messenger exfil endpoint IOC (VG1075), @tanstack/* Mini Shai-Hulud (84 malicious versions, May 2026), @wdio/browserstack-service command injection (CVE-2026-25244), @babel/plugin-transform-modules-systemjs arbitrary code (CVE-2026-44728), @opentelemetry exporter-prometheus DoS (CVE-2026-44902), systeminformation Linux cmd injection (CVE-2026-44724), velocityjs prototype pollution, defu, sharp, lodash, node-fetch, tar, xml2js, crypto-js, angular-expressions RCE, i18next-http-backend, vm2 sandbox breakouts
Deployment & Config
Vercel (vercel.json, cron secrets, headers), Next.js config, Docker, Docker Compose, Fly.io, Render, Netlify, Cloudflare
Infrastructure
Dockerfile security, GitHub Actions CI/CD, Terraform (S3, IAM, RDS, security groups)
Secrets & Environment
API keys (AWS, GitHub, Stripe, OpenAI, Resend, Turso), .env management, .gitignore coverage, high-entropy detection, NEXT_PUBLIC exposure
Compliance Control Mapping
Maps security findings to SOC2, PCI-DSS, HIPAA, GDPR, ISO27001, and EU AI Act (EUAIACT) controls. Identifies which code-level vulnerabilities are relevant to specific compliance requirements. Not a substitute for professional compliance audits.
Supply Chain
Malicious postinstall scripts, unpinned GitHub Actions, CI npm provenance / --ignore-scripts hardening (VG1070), typosquat detection, node-ipc protestware versions (VG1069), Miasma @redhat-cloud-services namespace compromise IOC (VG1074, RHSB-2026-006), Session messenger exfil endpoint IOC (VG1075, filev2.getsession.org), @tanstack/* Mini Shai-Hulud mass-malware versions (May 2026), @wdio/browserstack-service command injection via git branch names (CVE-2026-25244), lockfile poisoning patterns
Prompt-Level Security (Shift Left)
Most vulnerabilities in AI-generated code are born in the prompt: "add login to my app" says nothing about password hashing, session handling, or rate limiting — so the model picks defaults, and the defaults are where the CVEs live. secure_prompt moves the security gate to before code generation: it analyzes the raw prompt, detects the stack and attack surfaces it implies, matches them against GuardVibe's rule set, and returns a directive the host LLM uses to rewrite the prompt with security requirements embedded.
This is not a prompt beautifier. It is deterministic (no LLM, no network), it never restructures intent, and its first job is do no harm: a prompt that is already specific and security-aware gets verdict NO_MOD and passes through untouched.
NO_MOD— prompt is already specific and security-aware → proceed with the original prompt unchangedLIGHT_MOD— intent is clear but security constraints are missing → inject requirements onlyHEAVY_MOD— prompt is vague and security-relevant → inject requirements + surface clarifying questions (never invent the answers)
Before (what the user typed):
add login to my appAfter (what the host LLM executes, having applied the secure_prompt directive):
Add login to my app, with these security requirements:
- [VG001] Use environment variables or a secrets manager — never hardcode credentials.
- [VG1008] Always verify the caller has admin privileges before allowing role elevation.
- [VG105] Always specify allowed algorithms explicitly in jwt.verify().
Before implementing, confirm: which framework/stack is this for, and which auth
provider should be used (e.g. Clerk, Auth.js/NextAuth, Supabase Auth, custom JWT)?Same user intent — but the model now generates auth code with the guardrails stated up front, instead of GuardVibe catching the missing pieces after the fact.
Tools (39 MCP tools)
Tool | What it does |
| Analyze a code snippet for security issues |
| Scan multiple files with security scoring (A-F) |
| Scan a project directory from disk |
| Pre-commit scan of git-staged files — diff-aware (blocks only newly-staged lines; |
| Check all dependencies for known CVEs (OSV) — annotates each vulnerable package with reachability (is it actually imported in your source?) |
| Detect leaked secrets, API keys, tokens |
| Check individual packages against OSV |
| Typosquat detection, maintenance status, adoption metrics |
| Map security findings to compliance controls (SOC2, PCI-DSS, HIPAA, GDPR, ISO27001, EU AI Act) |
| SARIF v2.1.0 export for CI/CD integration |
| Security best practices and guides |
| Auto-fix suggestions with concrete patches for AI agents |
| Close the loop — scan, apply only the fixes that verifiably land (each re-scanned, rolled back on regression), return the verified code + a definition-of-done gate |
| Audit project configuration files for cross-file security misconfigurations |
| Detect project stack and generate tailored security policies (CSP, CORS, RLS) |
| Review PR diff for security issues with severity gating |
| Scan git history for leaked secrets (active and removed) |
| Check project against compliance policies defined in .guardviberc |
| Track tainted data flows from user input to dangerous sinks |
| Cross-file taint analysis — track tainted data across module boundaries |
| Analyze shell commands for security risks before execution |
| Compare config file versions to detect security downgrades |
| Assess overall repository security posture and map sensitive areas |
| Get detailed remediation guidance with exploit scenarios and fix strategies |
| Real-time single-file scan — designed for post-edit hooks |
| Scan only git-changed files — for PRs and incremental CI; diff-aware (only newly-added lines; |
| Cumulative security dashboard — scans, fixes, grade trend over time |
| Host security audit — CVE-2025-59536, CVE-2026-21852, MCP config, env scanner |
| Audit MCP server configurations for hook injection, file:// abuse, sensitive paths |
| Scan shell profiles, .env files for base URL hijack and credential sniffing |
| Verify a security fix was applied correctly — returns fixed/still_vulnerable/new_issues |
| Get recommended tool workflow for your current task (writing, pre-commit, PR review, etc.) |
| Auth coverage map — enumerate routes, parse middleware matchers, detect auth guards, report coverage % |
| LLM-powered deep analysis — IDOR, business logic, race conditions, auth bypass. Defaults to Claude Haiku 4.5 (~cents/scan). Pass |
| Single source of truth — runs ALL checks in one call, returns PASS/FAIL/WARN verdict + score + coverage % + deterministic result hash |
| Remediation plan — generates section-by-section fix checklist after audit |
| Remediation verification — compares before/after audit, flags skipped sections |
| Prompt-level security (shift left) — analyze a coding prompt BEFORE code is written; deterministic triage (NO_MOD/LIGHT_MOD/HEAVY_MOD), stack + attack-surface detection, severity-ranked GuardVibe requirements embedded via a rewrite directive |
| Slopsquat / AI-hallucination detector — flags phantom imports (imported but in no manifest) and typosquats fully offline + deterministic; opt-in online tier adds npm-registry truth (404 = nonexistent, brand-new low-download = slopsquat pattern). CLI: |
All scanning tools support format: "json" for machine-readable output.
Slopsquat / hallucinated-package detection
AI assistants invent package names — ~20% of AI-generated code references packages that don't exist, and attackers register those hallucinated names ("slopsquatting"). Commodity SCA scans known, published packages against vuln databases; it can't see a name that doesn't exist yet, was never installed, or was published yesterday. scan_hallucinated_packages / slopscan targets exactly that seam, at code-gen/PR time:
Offline (deterministic, air-gapped):
phantom_import(a package imported in source but absent from everypackage.json— a classic LLM tell) and typosquats of popular packages. Statement-anchored + comment/template-aware, so example imports in docs/strings are never miscounted.Online (opt-in, graceful degrade): npm-registry truth —
nonexistent(404), brand-new + low-download (slopsquat-registration pattern), deprecated/unmaintained.
The offline tier is also a full_audit section (online never runs inside the audit, keeping the result hash deterministic). Allowlist intentional unpublished/workspace names via .guardviberc:
{ "slopscan": { "online": true, "allow": ["@myorg/internal-pkg"] } }Security Rules (684 rules across 25 modules)
Category | Rules | Coverage |
Core OWASP | 39 | SQL injection, XSS, CSRF, command injection, CORS, SSRF, hardcoded secrets |
Next.js App Router | 18 | Server Actions, secret exposure, auth bypass, CSP, redirects |
Auth (Clerk / Auth.js / Supabase Auth) | 17 | Middleware, secret keys, session storage, role checks, SSR cookies |
Database (Supabase / Prisma / Drizzle) | 13 | Raw queries, client exposure, service role leaks, NoSQL injection, Drizzle identifier injection (CVE-2026-39356) |
OWASP API Security | 11 | BOLA/IDOR, mass assignment, pagination, rate limiting, error leaks |
Modern Stack | 47 | Zod, tRPC, Hono, GraphQL, Uploadthing, Turso, Convex, OAuth, CSP, webhooks, AI SDK, React Server Action validation (React2Shell) |
Deployment Config | 21 | Vercel, Next.js config, Docker Compose, Fly, Render, Netlify, Cloudflare, K8s secrets |
Payments (Stripe / Polar / Lemon) | 9 | Webhook signatures, key exposure, price manipulation |
Services (Resend / Upstash / Pinecone / PostHog) | 11 | API key leaks, PII tracking, email injection |
Web Security | 20 | Webhooks, CSP, .env safety, AI key exposure, cookie handling |
React Native / Expo | 10 | AsyncStorage secrets, deep links, ATS, hardcoded URLs |
Firebase | 7 | Firestore rules, admin SDK, storage, custom tokens |
AI / LLM Security | 33 | Prompt injection, MCP SSRF, excessive agency, indirect injection |
AI Host Security | 14 | CVE-2025-59536 hook injection, CVE-2026-21852 base URL hijack, MCP config audit |
AI Tool Runtime | 14 | MCP tool output sanitization, obfuscated descriptions, safety bypass |
CVE Version Intelligence | 309 | Known vulnerable versions in package.json — incl. Vite dev-server cmd injection (CVE-2024-52011), React Router 7 cluster (CVE-2026-33245/42211/42342), DOMPurify XSS (CVE-2026-47423), Better Auth bypass (CVE-2026-45337), Axios supply-chain backdoor |
Shell / Bash | 5 | Pipe to bash, chmod 777, rm -rf, sudo password |
SQL | 4 | DROP/DELETE without WHERE, stacked queries, GRANT ALL |
Supply Chain | 19 | Malicious install scripts, lockfile integrity, dependency confusion, typosquat detection |
Go | 6 | SQL injection, command injection, template escaping |
Dockerfile | 7 | Root user, secrets in ENV, untagged images, non-root user |
CI/CD (GitHub Actions) | 8 | Secrets interpolation, unpinned actions, write-all permissions |
Terraform | 6 | Public S3, open security groups, IAM wildcards |
Advanced Security | 31 | ReDoS, CRLF injection, race conditions, XXE, brute force, audit logging |
Other Services | 5 | AWS, GCP, MongoDB, Convex, Sentry, Twilio |
CLI Commands
# Scanning
npx guardvibe scan [path] # Scan a directory for security issues
npx guardvibe scan . --format json # JSON output for automation
npx guardvibe check <file> # Scan a single file
npx guardvibe diff [base] # Scan changed files — reports only newly-introduced issues
npx guardvibe diff [base] --all-lines # Include pre-existing findings in changed files too
# Close the loop — scan, apply verified fixes, re-verify
npx guardvibe secure-this <file> # Dry run: show the fixes that would land + remaining manual work
npx guardvibe secure-this <file> --write # Apply only the fixes that re-verify clean (rolled back on regression)
npx guardvibe secure-this <file> --format json
# Full security audit
npx guardvibe audit [path] # Full audit with PASS/FAIL verdict + hash
npx guardvibe audit . --format json # JSON output for CI pipelines
npx guardvibe audit --skip-deps # Skip dependency CVE check
npx guardvibe audit --full # Disable MCP-output truncation (full finding set)
# Host security audit
npx guardvibe doctor # Host hardening audit (project scope)
npx guardvibe doctor --scope host # + shell profiles, global MCP configs
npx guardvibe doctor --scope full # + home dir configs
npx guardvibe doctor --format json # JSON output
# LLM-powered deep scan (IDOR, business logic, race conditions, auth bypass)
npx guardvibe deep-scan <file> # Default: Haiku 4.5, all focus areas
npx guardvibe deep-scan <file> --focus idor # Narrow to IDOR
npx guardvibe deep-scan <file> --model sonnet # Deeper analysis (more expensive)
npx guardvibe deep-scan <file> --max-bytes 5000 # Truncate input for cost control
# Requires ANTHROPIC_API_KEY or OPENAI_API_KEY env var
# Setup
npx guardvibe init <platform> # Setup MCP server (claude, cursor, gemini, all)
npx guardvibe hook install # Install pre-commit hook
npx guardvibe hook uninstall # Remove pre-commit hook
npx guardvibe ci github # Generate GitHub Actions workflow
# Pre-commit / CI
npx guardvibe-scan # Scan staged files (for pre-commit)
npx guardvibe-scan --format sarif --output results.sarif # CI mode
# Options (scan commands)
# --format <type> scan / diff: markdown|json|sarif
# check: markdown|json|sarif|buddy|agent
# agent = guardvibe.agent.v1 — per finding: { id, severity, confidence, exactEdit, manualFix, verify }
# so an AI agent can apply the exact edit and run the verify step to prove the fix
# (an unsupported format errors rather than silently falling back to markdown)
# --output <file> Write results to file
# --fail-on <level> critical|high|medium|low|none — exit 1 when a finding at/above this level exists
# check, audit, and the pre-commit gate (guardvibe-scan / scan --staged) gate on
# critical by DEFAULT; scan and diff are reports (exit 0) unless --fail-on is passed
# --full Bypass response-size caps (50 JSON / 30 markdown / 200-file taint)Plugin System
Extend GuardVibe with custom or community rule packs.
npm install guardvibe-rules-awesomePlugins matching guardvibe-rules-*, @guardvibe/rules-*, or @guardvibe-pro/rules-* are discovered automatically.
Writing a Plugin
A plugin is an npm package that exports a GuardVibePlugin object:
// index.ts
import type { GuardVibePlugin } from "guardvibe/plugins";
const plugin: GuardVibePlugin = {
name: "my-rules",
version: "1.0.0",
description: "My custom security rules",
rules: [
{
id: "CUSTOM001",
name: "My Custom Rule",
severity: "high", // "critical" | "high" | "medium" | "low" | "info"
owasp: "A01:2025 Broken Access Control",
description: "What this rule detects and why it's dangerous",
pattern: /vulnerable_pattern_here/g, // RegExp with global flag
languages: ["javascript", "typescript"], // which file types to scan
fix: "How to fix the vulnerability",
fixCode: "// Copy-paste secure code example",
compliance: ["SOC2:CC6.1"], // optional compliance mapping
},
],
};
export default plugin;Plugin Rule Schema
Field | Type | Required | Description |
| string | Yes | Unique rule ID (e.g., "CUSTOM001") |
| string | Yes | Human-readable rule name |
| string | Yes |
|
| string | Yes | OWASP category mapping |
| string | Yes | What the rule detects |
| RegExp | Yes | Regex pattern to match vulnerable code (use |
| string[] | Yes | File types to scan |
| string | Yes | How to fix the issue |
| string | No | Copy-paste secure code example |
| string[] | No | SOC2/PCI-DSS/HIPAA control IDs |
Loading Plugins
Plugins are loaded from three sources:
Auto-discovery: Any installed npm package matching
guardvibe-rules-*or@guardvibe/rules-*Config-specified: Packages listed in
.guardvibercpluginsarrayLocal paths: Relative paths in
.guardvibercpluginsarray
// .guardviberc
{
"plugins": [
"guardvibe-rules-awesome",
"./my-local-rules"
]
}Configuration
Create a .guardviberc file in your project root:
{
"rules": {
"disable": ["VG030"],
"severity": {
"VG002": "medium"
}
},
"scan": {
"exclude": ["fixtures/", "coverage/"],
"maxFileSize": 1048576
},
"plugins": ["guardvibe-rules-awesome"]
}Inline Suppression
const key = process.env.API_KEY; // guardvibe-ignore VG001
// guardvibe-ignore-next-line VG002
app.get("/api/health", (req, res) => res.json({ ok: true }));Supports //, #, and <!-- --> comment styles.
GuardVibe Scans Itself
We run GuardVibe on its own codebase as a pre-commit hook. Every commit is scanned before it reaches the repository — the same workflow GuardVibe enables for your projects.
How It Works
You write code with AI
|
AI agent calls GuardVibe MCP tools
|
GuardVibe scans locally (no cloud, no API)
|
Returns findings with severity, OWASP mapping, and fix suggestions
|
AI agent fixes issues before they reach productionPerformance
Tested on real AI-built projects (837 files, Next.js + Supabase + Clerk):
Scan time: ~1.2s (837 files)
False positive rate: near zero — context-aware detection (React Native, Supabase client/server, static innerHTML, git-aware secrets)
Detection rate: 100% on known vulnerability patterns
Security score: A (99/100) on production projects
Troubleshooting
MCP connection issues
If your AI agent cannot connect to GuardVibe:
Restart your IDE/agent. MCP servers are started by the host application. After running
npx guardvibe init, restart Claude Code, Cursor, or Gemini CLI for the config to take effect.Check the config path. Run
npx guardvibe init claudeagain and verify the output shows the correct config file location (.mcp.jsonin your project root for Claude Code,.cursor/mcp.jsonfor Cursor).Re-run
initto upgrade. When upgrading GuardVibe, re-runnpx guardvibe init claude—.mcp.jsonis pinned to a specific version (e.g.guardvibe@3.1.36) at init time for fast deterministic startup. As of v3.1.2 the re-run also rewrites stale pins automatically (Upgraded GuardVibe pin (3.1.27 → 3.1.28)); since v3.1.27 the PostToolUse hook command is pinned to the same version (was@latest) and re-run upgrades a stale hook too. The same applies tonpx guardvibe hook installandnpx guardvibe ci github(since v3.1.3) — both are version-pinned at install/generate time and re-run to upgrade.Pre-3.1.1 users won't see the auto-update banner. GuardVibe started writing a once-per-day "newer version available" notice to stderr in v3.1.1. If your install predates that, you'll never see it — run
npx -y guardvibe@latest init <host>once to bake in the latest pin and start receiving banners on subsequent sessions.Verify Node.js version. GuardVibe requires Node.js >= 18.0.0. Check with
node --version.Check npx cache. If you upgraded GuardVibe and the old version is cached, run
npx -y guardvibe@latestto force the latest version.
Node.js version requirements
GuardVibe requires Node.js >= 18.0.0. Earlier versions will fail with syntax errors or missing APIs. Node.js 22 LTS is recommended.
False positives
If a rule triggers on safe code:
Inline suppression: Add
// guardvibe-ignore VG001on the same line, or// guardvibe-ignore-next-line VG001on the line above. Supports//,#, and<!-- -->comment styles.Config exclusion: Add the rule ID to
rules.disablein.guardviberc:{ "rules": { "disable": ["VG030"] } }Path exclusion: Add directories to
scan.excludein.guardviberc:{ "scan": { "exclude": ["fixtures/", "test-data/"] } }
Pre-commit hook issues
Hook not running: Verify the hook file exists at
.git/hooks/pre-commitand is executable (chmod +x .git/hooks/pre-commit).Hook blocking valid commits: Use
git commit --no-verifyto skip the hook temporarily, then investigate the findings.Removing the hook: Run
npx guardvibe hook uninstall.
Security Model
GuardVibe is designed for use on sensitive and proprietary codebases:
100% local execution. All scanning happens on your machine. No code, findings, or metadata are sent to any server.
No accounts, no API keys, no telemetry. There is no signup, no cloud dashboard, and no usage tracking of any kind.
One optional network call. The
scan_dependenciesandcheck_dependenciestools query the OSV API to check for known CVEs. This is opt-in -- you only call it when you explicitly use those tools. No other tool makes network requests.Safe for air-gapped environments. All code analysis rules run entirely offline. Only dependency vulnerability checks require network access.
Configuration (.guardviberc)
Create a .guardviberc JSON file in your project root to customize GuardVibe behavior.
Full example
{
"rules": {
"disable": ["VG030", "VG045"],
"severity": {
"VG002": "medium",
"VG010": "low"
}
},
"scan": {
"exclude": ["fixtures/", "coverage/", "dist/", "vendor/"],
"maxFileSize": 1048576
},
"plugins": [
"guardvibe-rules-awesome",
"./my-local-rules"
],
"compliance": {
"frameworks": ["SOC2", "HIPAA"],
"failOn": "high",
"exceptions": [
{
"ruleId": "VG030",
"reason": "Accepted risk per security review 2026-03",
"approvedBy": "security-team",
"expiresAt": "2026-12-31",
"files": ["src/legacy/**"]
}
],
"requiredControls": ["SOC2:CC6.1"]
},
"scoring": {
"densityModel": "exponential"
}
}Configuration fields
Field | Type | Default | Description |
|
|
| Rule IDs to skip during scanning |
|
|
| Override severity for specific rules |
|
|
| Glob patterns for directories/files to skip |
|
|
| Maximum file size in bytes (files larger than this are skipped) |
|
|
| npm package names or local paths to load as plugins |
|
| -- | Compliance frameworks to map against ( |
|
|
| Minimum severity that causes compliance failure |
|
|
| Approved exceptions with expiration dates |
|
| -- | Controls that must pass regardless of exceptions |
|
|
| Score decay curve. |
Security
GuardVibe takes supply chain security seriously:
npm provenance — every published version is cryptographically signed via Sigstore, linking the package to this exact GitHub repo and commit. Verify with
npm audit signatures2FA enabled — npm account protected with two-factor authentication
Branch protection — force push disabled on main, admin enforcement enabled
Tag protection — version tags (
v*) cannot be deleted or force-pushedMinimal CI permissions — GitHub Actions workflows use
permissions: contents: readonlyMinimal, fully-audited runtime dependencies — only three direct dependencies: the MCP SDK, Zod, and the TypeScript compiler (used for AST-based dataflow analysis). Zod and TypeScript are zero-sub-dependency, pure-JS packages. The MCP SDK pulls a small set of widely-used, audited transitive packages (e.g.
express,cors,ajv) for its optional HTTP transport — GuardVibe itself runs over stdio. No native bindings anywhere in the tree, and all code analysis runs 100% locally and offline
To report a vulnerability, please email info@goklab.com or open a GitHub issue.
License
Apache 2.0 — open source, patent-safe, enterprise-ready. Built by GokLab.
Available Tools
39 toolsanalyze_cross_file_dataflowA
Track user input flowing across module boundaries — detects injection vulnerabilities spanning multiple files. Pass files array with file contents. For single-file analysis, use analyze_dataflow instead. Example: analyze_cross_file_dataflow({files: [{path: 'src/api.ts', content: '...'}, {path: 'src/db.ts', content: '...'}]})
Inputs: path, files, format.
analyze_dataflowA
Track user input (request body, URL params, form data) flowing into dangerous sinks (SQL queries, eval, file operations, redirects). Detects injection vulnerabilities that regex rules miss by following variable assignments through code.
Inputs: code (required), language (required), format.
audit_configA
Audit application config files (next.config, middleware, .env, vercel.json) for cross-file security gaps: missing headers, unprotected routes, exposed secrets. NOT the same as guardvibe_doctor which checks AI host security (MCP configs, hooks). Example: audit_config({path: '.'})
Inputs: path (required), format.
audit_mcp_configA
Scan MCP configuration files (.claude/settings.json, .cursor/mcp.json, .vscode/mcp.json) for security issues: malicious hooks (CVE-2025-59536), suspicious MCP servers, overly permissive tool access, and shell injection patterns. Use this to verify MCP configurations are safe before use.
Inputs: path, format.
auth_coverageA
Analyze authentication coverage across Next.js App Router routes. Detects auth guards (Clerk, NextAuth, Supabase, custom) and reports protected vs unprotected routes. Pass files array with route file contents and middleware content. Example: auth_coverage({files: [{path: 'app/api/users/route.ts', content: '...'}], middleware: '...'})
Inputs: path, files, format, middleware.
check_codeA
Analyze inline code for security vulnerabilities (OWASP Top 10, XSS, SQL injection, insecure patterns). Pass code as a string parameter. For scanning files on disk, use scan_file instead. Example: check_code({code: 'app.get(...)', language: 'javascript'})
Inputs: code (required), language (required), format, framework.
check_commandA
Analyze a shell command for security risks before execution. Returns allow/ask/deny verdict with blast radius, safer alternatives, and context-aware risk assessment. Detects: destructive ops, git history rewrites, secret exposure, data exfiltration, deploy triggers, privilege escalation, database drops.
Inputs: command (required), cwd, branch, format.
check_dependenciesA
Check npm, PyPI, or Go packages for known security vulnerabilities (CVEs) using the OSV database. Use this before adding new dependencies or to audit existing ones.
Inputs: packages (required), format.
check_package_healthA
Check npm packages for typosquat risk, maintenance status, adoption metrics, and deprecation. Use this before adding new dependencies to catch suspicious or risky packages.
Inputs: packages (required), format.
check_projectA
Scan multiple files for security vulnerabilities and generate a project-wide security report with a security score. Use this for comprehensive security audits.
Inputs: files (required), format.
compliance_reportA
Map security findings to compliance controls (SOC2, PCI-DSS, HIPAA, GDPR, ISO27001, EUAIACT). Scans a directory and groups issues by control. Output includes a summary section at the top; for large projects, findings are truncated to top 50. Use mode=executive for C-level summary. Example: compliance_report({path: '.', framework: 'SOC2'})
Inputs: path (required), framework (required), mode, format.
deep_scanA
LLM-powered deep security analysis for vulnerabilities that pattern-matching cannot detect: IDOR, business logic flaws, race conditions, stale auth, mass assignment, privilege escalation. Defaults to Claude Haiku 4.5 (~cents per scan); pass model: 'sonnet' for deeper analysis at higher cost. Requires ANTHROPIC_API_KEY or OPENAI_API_KEY env var.
Inputs: code (required), language (required), focus, model, +4 more.
explain_remediationA
Pass a GuardVibe rule ID (e.g. VG154) to get a detailed explanation: risk assessment, exploit scenario, minimum fix, secure alternative, and test strategy. Optionally pass the affected code snippet for context-aware guidance. Example: explain_remediation({rule_id: 'VG402'})
Inputs: rule_id (required), code, format.
export_sarifB
Scan a directory and export results in SARIF v2.1.0 format for CI/CD integration (GitHub, GitLab, Azure DevOps). Returns JSON string.
Inputs: path (required).
fix_codeA
Pass vulnerable code as a string and get fix suggestions with before/after patches. Returns structured edit instructions (line numbers, severity, confidence). Use verify_fix afterwards to confirm the fix resolved the issue. Example: fix_code({code: '...', language: 'typescript'})
Inputs: code (required), language (required), format, framework.
full_auditA
Single command that runs ALL checks: code scan (429 rules), secret detection, dependency CVEs, config audit, taint analysis, and auth coverage. Returns PASS/FAIL/WARN verdict with deterministic hash. IMPORTANT: If verdict is FAIL or WARN, you MUST call remediation_plan next to get a section-by-section fix checklist — do NOT skip any section. After fixing, call verify_remediation to confirm ALL sections are addressed. Example: full_audit({path: '.'})
Inputs: path, format, skipDeps, skipSecrets.
generate_policyB
Auto-detect project stack (Next.js, Supabase, Stripe, Clerk, Prisma, etc.) and generate tailored security policies. Outputs ready-to-use CSP headers, CORS configuration, Supabase RLS policies, rate limiting rules, and security headers based on detected frameworks.
Inputs: path (required), format.
get_security_docsA
Get security best practices and remediation guidance for a specific topic, framework, or vulnerability type. Covers OWASP Top 10, framework-specific hardening (Next.js, Supabase, Stripe), and secure coding patterns. Returns actionable guidance with code examples.
Inputs: topic (required).
guardvibe_doctorA
Check AI host security: MCP configurations, hooks, base URL hijacking, environment variable exposure. NOT the same as audit_config which checks application config files (next.config, .env, headers). Use scope=project (default) for project-only, scope=host to include shell profiles and global AI configs. Example: guardvibe_doctor({scope: 'project'})
Inputs: path, scope, format.
policy_checkA
Check project against compliance policies defined in .guardviberc. Use this in CI/CD pipelines to enforce security gates, or before releases to verify compliance requirements are met. Validates custom framework requirements, severity thresholds, required controls, and risk exceptions. Returns pass/fail status with detailed findings per control.
Inputs: path (required), format.
remediation_planA
Generate a mandatory section-by-section remediation plan from full_audit results. MUST be called after full_audit when verdict is FAIL or WARN. Returns ordered steps for ALL 6 sections (secrets, code, dependencies, config, taint, auth-coverage) with specific tool calls and actions. AI assistants MUST complete every section — skipping sections is not allowed. Example: remediation_plan({path: '.'})
Inputs: path, format.
repo_security_postureB
Analyze a repository's overall security posture. Maps sensitive areas (auth, payments, PII, admin, API, infrastructure), identifies high-risk workflows, recommends guard mode, and lists priority fixes.
Inputs: path (required), format.
review_prA
Review a pull request for security issues. Scans only changed lines (diff-only mode) and produces output for GitHub Check Runs, PR comments, or inline annotations. Supports severity gating to block PRs.
Inputs: base, path, format, fail_on, +1 more.
scan_changed_filesA
Scan only files that have changed since a given git ref (branch, commit, or HEAD~N). Ideal for PR checks, pre-push hooks, and incremental CI. Diff-aware by default: returns only findings on newly-added lines (set diff_aware:false for whole changed files).
Inputs: base, path, format, diff_aware.
scan_config_changeA
Compare before/after versions of a config file to detect security downgrades: CORS relaxation, CSP weakening, HSTS removal, debug mode, cookie flag changes, TLS disabling, new hardcoded secrets, removed security headers.
Inputs: after (required), before (required), format, file_path.
scan_dependenciesA
Parse a lockfile or manifest (package.json, package-lock.json, requirements.txt, go.mod) and check all dependencies for known CVEs via the OSV database. Reads the file directly. Use this after installing dependencies, during CI, or when auditing existing projects for vulnerable packages.
Inputs: manifest_path (required), format.
scan_directoryA
Scan all files in a directory on disk for security vulnerabilities. Pass a directory path — reads files from filesystem. Returns security score (A-F) and findings. Results may be truncated for large projects — check fileRanking in JSON output for top files. Example: scan_directory({path: './src'})
Inputs: path (required), format, exclude, baseline, +1 more.
scan_fileA
Scan a single file on disk by path for security vulnerabilities. Pass a file path — the tool reads the file itself. For inline code snippets, use check_code instead. The 'agent' format returns the structured guardvibe.agent.v1 contract (finding + exact edit + confidence + verify step). Example: scan_file({file_path: 'src/api/route.ts', format: 'agent'})
Inputs: file_path (required), format.
scan_hallucinated_packagesA
Detect AI-hallucinated and slopsquatted packages in a repo — the supply-chain seam commodity SCA misses. OFFLINE (deterministic): flags phantom imports (a package imported in source but absent from every package.json — a classic LLM hallucination tell) and typosquats of popular packages. ONLINE (opt-in, default on; gracefully degrades offline): adds npm-registry truth — packages that return 404 (definitive hallucination) and brand-new low-download packages (slopsquat-registration pattern). Run on AI-generated code at PR time, before npm install. Pass online:false for a fully deterministic, air-gapped scan.
Inputs: path, format, online.
scan_host_configB
Scan host environment for AI security issues: API base URL hijacking (CVE-2026-21852), credential exposure in shell profiles, .env file leaks, and environment variable sniffing. Checks .env files at project scope; add scope=host to also check shell profiles and global AI configs.
Inputs: path, scope, format.
scan_secretsB
Scan files and directories for leaked secrets, API keys, tokens, and credentials. Detects high-entropy strings, known API key patterns (AWS, Stripe, OpenAI, GitHub, Supabase), exposed .env files, and missing .gitignore coverage. Returns findings with exact line numbers and remediation steps.
Inputs: path (required), format, recursive.
scan_secrets_historyA
Scan git history for leaked secrets. Finds secrets that were committed in the past — even if they were later removed. Marks each finding as 'active' (still in code) or 'removed' (in git history only, needs rotation).
Inputs: path (required), format, max_commits.
scan_stagedA
Scan git-staged files for security vulnerabilities before committing. Run this before every commit to catch issues early. No input needed — automatically reads staged files. Diff-aware by default: reports only issues on newly-staged lines (set diff_aware:false for whole staged files).
Inputs: format, diff_aware.
secure_promptA
Shift-left security at the prompt level: analyze a raw coding prompt BEFORE any code is written and return a structured enhancement directive that embeds GuardVibe security requirements (auth checks, input validation, webhook signature verification, SQL injection prevention, secrets handling) into the prompt you are about to execute. Deterministic — no LLM, no network: triage verdict NO_MOD (prompt already specific and security-aware → proceed with the ORIGINAL prompt unchanged), LIGHT_MOD (inject missing security constraints only), or HEAVY_MOD (also surface clarifying questions — never invent answers to them). Detects stack (Next.js, Supabase, Clerk, Stripe, Prisma, Express, Hono...) and attack surfaces (auth, payments, file upload, user input, SQL, secrets, redirects) from the prompt text, matches them against GuardVibe's rule set, and returns verdict + intent summary + numbered [rule-id] requirements + rewrite directive. Call this with the user's prompt before generating code; prevents vulnerabilities before code generation instead of scanning after. Example: secure_prompt({raw_prompt: 'add login to my app'})
Inputs: raw_prompt (required), context.
secure_thisA
Close the loop on vulnerabilities in code: scan, apply only the fixes that VERIFIABLY land (each candidate edit is re-scanned and rolled back if it fails to resolve the issue or introduces a new one), and return the verified code plus a definition-of-done gate. Prefer this over fix_code+verify_fix when you want a guarantee the fix landed — not just a suggestion. Returns { status: clean|secured|partial|no_autofix, fixedCode, applied[], remaining[], definitionOfDone:{passed,message}, proofTest }. Write fixedCode to disk, then require definitionOfDone.passed before claiming the task complete; anything in remaining[] needs a manual fix. When fixes were applied, proofTest is a runnable regression test (GuardVibe-as-oracle) you can drop into the project to guard against regressions. Example: secure_this({code: '...', language: 'typescript'})
Inputs: code (required), language (required), filePath, framework.
security_statsA
Show cumulative security statistics, grade trend, and vulnerability fix progress for this project. Use this to demonstrate the value of GuardVibe security scanning over time. Data is stored locally in .guardvibe/stats.json.
Inputs: path, format, period.
security_workflowA
Get the recommended GuardVibe tool sequence for your current task. Returns which tools to call, in what order, and with what parameters. Use this when unsure which tool to use. Example: security_workflow({task: 'pre_commit'})
Inputs: task (required).
verify_fixB
Verify that a specific security fix was applied correctly. Re-scans the updated code and checks if the target vulnerability (by rule ID) is resolved. Returns 'fixed', 'still_vulnerable', or 'new_issues' status with details.
Inputs: code (required), ruleId (required), language (required), filePath.
verify_remediationA
Compare before/after audit results to verify ALL sections were addressed. MUST be called after completing remediation to confirm success. Runs a fresh audit and compares against the before snapshot. Explicitly flags skipped sections and refuses to return 'complete' status unless every section is addressed. Pass the before audit hash or let it re-run. Example: verify_remediation({path: '.', before_hash: 'abc123'})
Inputs: path, format, before_hash.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 39 tools
The descriptions make an effort to distinguish similar tools, e.g. scan_file vs check_code and audit_config vs guardvibe_doctor. However, the set still contains many overlapping scan/audit entry points such as full_audit, check_project, scan_directory, deep_scan, scan_staged, scan_changed_files, and review_pr, which could easily be misselected. Boundaries are documented but not clean enough for high confidence.
Many tools follow a verb_noun pattern (scan_file, scan_secrets, check_dependencies, generate_policy), but the set also includes noun_verb forms (compliance_report, policy_check, security_stats, auth_coverage) and other styles like full_audit, secure_this, guardvibe_doctor, and deep_scan. The names are generally readable, but the convention is mixed rather than predictable.
39 tools is heavy for an MCP server and likely exceeds what an agent can reliably navigate without a routing layer. While security auditing is broad, the surface includes many closely related scanners and verifiers that could be consolidated. The count feels oversized relative to the core workflows.
The surface covers a very broad security lifecycle: prompt hardening, code/config/secret/dependency scanning, dataflow and auth analysis, remediation planning, fix application, verification, compliance reporting, and CI export. Coverage is strong, with only minor gaps around consolidated workflows or direct runtime/dynamic testing. Overall it is complete for a static application-security auditing domain.
Maintenance
Related MCP Connectors
Zero-config MCP security scanner for AI-generated apps. 25K+ vulnerability patterns.
Security scanner for MCP servers. Detect vulnerabilities, prompt injection, and tool poisoning.
Security scanner for AI-written code: SAST, secrets, dependencies, IaC, containers and DAST.
Security scanner for AI agents and MCP servers: injection, jailbreak, tool abuse.
Related MCP Servers
- AlicenseNot gradedqualityFmaintenancePredeploy security scanner for AI-generated code. 80+ vulnerability patterns across secrets, auth, injection, config, Supabase, and logging. Runs locally, code never leaves your machine. Optional x402 witnessed attestation.96 npmApache 2.0
- AlicenseNot gradedqualityCmaintenanceOpen-source AI code review MCP server for local git diff auditing with deterministic security rules and AI-powered analysis using any OpenAI-compatible model.4MIT
- AlicenseNot gradedqualityCmaintenanceSecurity scanner for MCP servers — vet an MCP before you wire it into an agent. Detects prompt-injection, credential exfiltration (via taint analysis), RCE, and supply-chain risks, and catches cross-server exfil chains no single server reveals. Zero-dependency local CLI, SARIF output, CI-gateable, no account.60 npmMIT
- AlicenseCqualityDmaintenanceSecurity scanner and MCP server that catches dangerous patterns in MCP servers and AI agent projects, such as leaked secrets, shell execution, and prompt-injection text. Runs as both a CLI and MCP server with CI-friendly severity gates.21MIT