@repomend/mcpofficial
A
licenseNot graded
qualityD
maintenanceSecurity scanning MCP server that connects Claude to RepoMend findings, enabling vulnerability management and automated fix drafting.
MIT
Codex Security Cloud MCP
The Codex Security Cloud MCP server allows AI agents to interact with Codex Security Cloud to inspect, manage, and remediate security findings across your repositories.
List Security Metadata: Retrieve accessible repositories and author filters within your Codex Security Cloud account.
List Findings: Browse open or closed security findings with filtering by repository, severity/criticality, author, patch availability, sort order, and pagination via cursor.
Get Finding Details: Fetch detailed information about a specific finding, optionally including the full description, generated patch diff, or deeper evidence (source content, validation reports, attack-path evidence).
Close a Finding: Mark a finding as resolved with a status of
fixed,wontfix,duplicate, orfalse_positive, along with a reason.Reopen a Finding: Reopen a previously closed finding, resetting its status to
new.Request a Site-Side PR: Trigger Codex Security Cloud to generate a patch and open a pull request on the remote repository, then poll for the resulting PR URL and state.
Apply a Generated Patch Locally: Apply a generated security patch to a local git repository, automatically commit it, and optionally close the finding as fixed — with safety checks for staged/dirty files and a dry-run before applying.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Codex Security Cloud MCPlist open findings for repo my-app"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Codex Security Cloud MCP
MCP server for the Codex Security Cloud service exposed by ChatGPT/Codex Cloud.
The server assumes the user already has Codex installed and authenticated. It reads the existing Codex auth file and does not implement a separate login flow. By default it reads ~/.codex/auth.json; set CODEX_AUTH_JSON_PATH only if your Codex auth file lives somewhere else. It never asks users to paste tokens.
Install
Prerequisites:
Node.js 20 or newer
Codex installed and authenticated with
codex loginAccess to Codex Security Cloud for the repositories you want to inspect
Install for Codex:
codex mcp add codex-security-cloud -- npx -y codex-security-cloud-mcp@latestManual Codex configuration:
[mcp_servers.codex-security-cloud]
command = "npx"
args = ["-y", "codex-security-cloud-mcp@latest"]
enabled = trueFor other MCP clients, configure a stdio server command:
npx -y codex-security-cloud-mcp@latestQuick smoke test after installing:
Use the Codex Security Cloud MCP to list one open finding for my repositories.Related MCP server: ai-devtool-mcp-server
Safety
This MCP can read Codex Security Cloud findings, close/reopen findings, request site-side PRs, and apply generated patches to local git repositories. apply_generated_patch refuses staged changes, refuses touched files with local changes, runs git apply --check first, and creates a local commit for rollback if the patch applies.
Tools
list_security_metadata: lists accessible repos and author filters.list_findings: lists open or closed findings with repo, severity, patch, author, sort, cursor, and limit filters.get_finding: fetches normalized finding detail, including generated patch metadata when present.close_finding: closes a finding asfixed,wontfix,duplicate, orfalse_positive.reopen_finding: reopens a closed finding asnew.request_site_pr: asks the cloud service to start its site-side patch/PR workflow, then briefly polls the finding for PR URL/state metadata.apply_generated_patch: applies an already-generated patch locally, commits it, and optionally closes the finding as fixed.
Use the findingId returned by list_findings for get_finding, close/reopen, PR, and patch tools. The MCP intentionally omits backend-only ids and raw payloads from normal responses.
list_findings is intentionally compact so an agent can choose what to inspect without loading every finding body. get_finding is also compact by default: it includes a derived summary, compact relevant-line locations, generated patch metadata, and site PR metadata. The summary is extracted from an explicit Summary/Overview section when present, otherwise from the first paragraph with a bounded length. Use includeDescription: true when an agent needs the exact full description from the endpoint. Use includePatchDiff: true only when an agent needs to inspect or manually repair the generated patch. Use includeEvidence: true only when an agent needs relevant-line source content, validation/fix reports, or attack-path evidence. apply_generated_patch fetches the generated diff internally, so applying a clean generated patch does not require loading the diff into model context.
apply_generated_patch fails before applying if the generated patch is missing, the repository has staged changes, the patch touches dirty files, or git apply --check fails. On failure it returns the phase, a compact finding reference, current HEAD, expected base commit, touched files, git stderr, and the suggested commit message so an agent can take over manually.
If autoClose is true, the close happens only after a successful local commit. The close reason uses neutral wording:
An agent applied and committed the generated patch on <date time>.
Commit: <sha>Development
npm install
npm run build
node ./dist/server.jsAvailable Tools
7 toolsapply_generated_patchApply Generated PatchA
Apply an already-generated Codex Security Cloud patch to a local git repo, commit it, and optionally close the finding as fixed.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| findingId | Yes | Action-safe finding id returned by list_findings or get_finding. | |
| repoPath | Yes | ||
| autoClose | No |
TDQS
A3.5/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that the tool modifies a local git repo (applies and commits) and optionally closes a finding, but lacks details on failure scenarios, rollback, or idempotency.
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 description is a single, clear sentence with no fluff, efficiently conveying the core action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is too brief. It lacks essential context about repo state requirements, the source of the patch, and potential side effects, making it incomplete for an agent without additional knowledge.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is only 33% (only findingId has a description in schema). The description adds no parameter explanations; repoPath and autoClose remain undocumented, so the description does not compensate for low coverage.
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 clearly states the action (apply, commit, optionally close) and the resource (an already-generated Codex Security Cloud patch), distinguishing it from siblings like close_finding that only close findings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when a patch is already generated, but does not explicitly state when to use this tool vs alternatives like request_site_pr, nor does it mention prerequisites or when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
close_findingClose FindingB
Close a Codex Security Cloud finding as fixed, won't fix, duplicate, or false positive.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| findingId | Yes | Action-safe finding id returned by list_findings or get_finding. | |
| version | Yes | ||
| status | Yes | ||
| reason | Yes |
TDQS
B3.1/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description carries full burden. It does not disclose idempotency, permission requirements, side effects (e.g., whether the finding becomes inactive), or behavior if already closed. Only the allowed statuses are listed, which are already in the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no wasted words. Could be slightly more structured (e.g., listing statuses inline is acceptable), but conciseness is achieved without sacrificing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, 4 required parameters, and no annotations, the description is incomplete. It does not explain return values, error conditions, or preconditions for mutation. An agent cannot fully understand the tool's behavior from this definition alone.
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 low (25%). The description adds useful context for findingId (references list_findings/get_finding) and enumerates statuses, but version and reason lack semantic explanation. The description partially compensates for low schema coverage but not fully.
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 clearly states the tool's purpose: closing a Codex Security Cloud finding with specific statuses. It distinguishes itself from sibling tools like reopen_finding by specifying the closing action and listing the valid status categories.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives such as reopen_finding. The description does not mention prerequisites, context for each status, or scenarios where close_finding is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_findingGet FindingA
Fetch one Codex Security Cloud finding. Compact by default; opt into generated patch diff or deeper evidence only when needed.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| findingId | Yes | Action-safe finding id returned by list_findings or get_finding. | |
| includePatchDiff | No | ||
| includeEvidence | No | ||
| includeDescription | No |
TDQS
A3.6/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses default compact mode and optional inclusions, but doesn't detail what 'compact' means, the return format, or any safety traits. It's adequate but not thorough.
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?
Two concise sentences with no extraneous information. Front-loads the core purpose and adds value with the opt-in behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without output schema, the description lacks details on return structure or field meanings. It doesn't explain what a 'finding' is or how the compact/default response differs from expanded ones, which is needed for a fetch tool.
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 coverage is low (25%), but description hints at includePatchDiff and includeEvidence as 'opt into generated patch diff or deeper evidence'. However, it doesn't explicitly map parameters or explain includeDescription, leaving some ambiguity.
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?
Description clearly states 'Fetch one Codex Security Cloud finding' with a specific verb and resource. It distinguishes from sibling tools like list_findings by focusing on a single finding and offers optional expansions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use (for a single finding) and mentions optional expansions, but lacks explicit guidance on when not to use it or direct comparisons to siblings like list_findings or close_finding.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_findingsList FindingsC
List Codex Security Cloud findings in the open or closed section with filters.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| section | No | open | |
| repos | No | ||
| criticality | No | ||
| hasPatch | No | ||
| author | No | ||
| sort | No | ||
| cursor | No | ||
| limit | No |
TDQS
C2.4/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and description does not disclose key behaviors such as pagination (cursor, limit), sorting, or the read-only nature of the operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief but lacks structured details; it is front-loaded but incomplete, missing bullet points or examples.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 8 parameters, no output schema, and no annotations, the description is severely inadequate, leaving out pagination, response format, and filter interactions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description only mentions 'section' and 'filters' generically, failing to explain crucial parameters like repos, criticality, hasPatch, author, sort, cursor, and limit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists findings in open or closed sections with filters, but lacks differentiation from sibling tools like get_finding or close_finding.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives; simply says 'with filters' without further context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_security_metadataList Security MetadataC
List accessible Codex Security Cloud repositories and author filters.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| forceRefreshRepos | No | ||
| repo | No |
TDQS
C2.6/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must disclose behavioral traits. It only mentions 'accessible' but lacks details on pagination, ordering, read-only nature, or performance implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (one sentence) but is too minimal, leaving out important context. It is not verbose, but efficiency is compromised by lack of substance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has two parameters, no output schema, and no annotations, the description should provide more context (e.g., pagination, filtering behavior). It fails to do so, making it incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no descriptions for its two parameters (forceRefreshRepos, repo). The description adds minimal meaning by mentioning 'repositories and author filters' but does not explain the parameters' roles or expected values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (list) and resource (Codex Security Cloud repositories and author filters), and it distinguishes from sibling tools focused on findings and patches. However, it could be more precise about what 'author filters' entails.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The sibling tools are about findings and patches, but the description does not explicitly state use cases or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
reopen_findingReopen FindingC
Reopen a closed Codex Security Cloud finding.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| findingId | Yes | Action-safe finding id returned by list_findings or get_finding. | |
| version | Yes |
TDQS
C2.9/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must disclose behavior. It does not mention side effects, state changes, error conditions, or authentication requirements. Only that the finding must be 'closed' is implied but not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (one sentence) and front-loaded with the verb. However, it sacrifices necessary detail, making it too minimal for effective guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is insufficient. It does not explain version's purpose, return values, or error scenarios, leaving gaps that an agent cannot fill.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50% (findingId described, version not). The description adds no parameter meaning, failing to explain version's role (e.g., optimistic locking) or complement the existing schema descriptions.
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 'Reopen a closed Codex Security Cloud finding' clearly states the action (reopen) and the resource (closed finding), distinguishing it from sibling tools like close_finding, get_finding, and list_findings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives (e.g., close_finding), nor does it mention prerequisites, permissions, or context. It is purely declarative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
request_site_prRequest Site PRA
Ask Codex Security Cloud to generate its site-side patch/PR workflow for a finding.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| findingId | Yes | Action-safe finding id returned by list_findings or get_finding. |
TDQS
A3.7/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Only states it generates a workflow; no mention of side effects, permissions, or what happens after invocation.
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?
Single sentence, no fluff, front-loaded with all necessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description is adequate but leaves ambiguity about what 'site-side patch/PR workflow' means and what the outcome is.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%. Description adds value by specifying that findingId is 'Action-safe' and listing source tools (list_findings, get_finding).
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?
Description clearly states the action (ask Codex Security Cloud to generate) and the resource (site-side patch/PR workflow for a finding). It differentiates from siblings like apply_generated_patch.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance. Implies usage for a finding but lacks context on prerequisites or alternatives.
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. Dates show when Glama detected each change.
7 tool updates
v0.1.0- First observed
apply_generated_patch - First observed
close_finding - First observed
get_finding - First observed
list_findings - First observed
list_security_metadata - First observed
reopen_finding - First observed
request_site_pr
TDQS
A3.5/5.0
Disambiguation5/5
Each tool targets a distinct action (listing, fetching, closing, reopening, applying patches, requesting PRs, listing metadata) with no overlapping purposes, making agent selection unambiguous.
Naming Consistency5/5
All tool names follow a consistent snake_case verb_noun pattern (e.g., list_findings, close_finding), providing predictable and readable naming.
Tool Count5/5
Seven tools is well-scoped for a security findings server, covering essential operations without being too few (each tool has a clear role) or too many (no redundancy).
Completeness5/5
The tool set covers the full finding lifecycle: list, get, close, reopen, apply patch, and request site-side PR. Missing creation is natural (findings generated by system), and no dead ends exist.
Maintenance
ActivityMaintained
ResponsivenessNo issues
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
An MCP server that let you interact with Cycloid.io Internal Development Portal and Platform
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
Authenticated MCP server for ClearPolicy policy and compliance workflows.
Related MCP Servers
- FlicenseNot gradedqualityBmaintenanceMCP server for AI DevTool workflow, exposing tools and resources for code review, repository chat, and repository operations.1-
- FlicenseNot gradedqualityBmaintenancePrivate MCP server that enables a single GitHub identity to run Codex Security CLI scans on registered repositories, with OAuth authentication and a web-based cockpit UI.-
- AlicenseNot gradedqualityBmaintenanceMCP server that provides coding agents with structured repository context, including graph-based navigation, dependency analysis, runtime flow tracing, and configuration surface across supported stacks.55MIT
Appeared in Searches
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/obinnanwachukwu1/codex-security-cloud-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server