Skip to main content
Glama
604,258 tools. Updated 2026-09-23 18:25

"A server for finding GitHub repositories and resources" matching MCP tools:

  • Returns the plain-language meaning and step-by-step fix for one Malinois finding. Use it while helping the user fix an issue reported by scan_app, or when they ask what a finding means. Pass the rule_id exactly as scan_app returned it. Read-only, no network, instant.
    ConnectorNo auth
  • Scan a public GitHub MCP-server repository for security issues. Clones the repo (shallow, <60s, <200 MB), runs compuute-scan v0.6.2 in static analysis mode (no code execution from the target), and returns a structured report with severity counts, a 0-100 score, and the 10 most severe findings. WHEN TO USE: - Before connecting to an unknown MCP server discovered via Anthropic Registry, Smithery, mcp.so, or a Discord recommendation. - Before installing a third-party MCP-server package into a production pipeline. - As part of an agent's pre-commit / pre-deploy due-diligence step when adding new dependencies. - As one input to a multi-source trust evaluation (combine with publisher reputation, package install count, last-update recency). WHEN NOT TO USE: - For private repos. Use the on-prem CLI instead: `npx compuute-scan ./path-to-private-repo` - For deep exploitability assessment of a specific code path. This is pattern matching, not dataflow analysis. Book a manual L2-L4 audit at https://compuute.se/audit for that depth. - For non-GitHub hosts (GitLab, Bitbucket, self-hosted). v1 supports github.com only. - For repos > 200 MB or clone time > 60s. The endpoint returns a 413 or 504 in those cases — fall back to local CLI. EXPECTED RESPONSE TIME: - Median: ~1-2 seconds for small repos (<100 files). - p99: ~10 seconds for medium repos. - Hard timeout at clone=60s, scan=120s combined. EXPECTED COST: - Free tier in MVP. Future Pro tier may charge per-scan or per-month. DATA FRESHNESS: - Scanner version is reported in response.scanner.version. - L1 rule set freshness reflects compuute-scan releases — see github.com/Compuute/compuute-scan/CHANGELOG.md for the latest CVE and threat-intel response timeline. EXAMPLES: Example 1 — scan an MCP server you're evaluating: github_url = "https://github.com/modelcontextprotocol/servers" → score: 0, summary: {critical: 1, high: 94, medium: 22} → top_findings include SSRF, eval, etc. → recommendation: "AVOID — 1 critical and 94 high finding(s)..." Example 2 — scan a clean reference implementation: github_url = "https://github.com/microsoft/azure-devops-mcp" → score: 90+, summary: {critical: 0, high: 1} → recommendation: "REVIEW — 1 high finding(s)..." Example 3 — scan your own dev MCP-server before publishing: github_url = "https://github.com/yourorg/your-mcp" → audit your own surface before others install it OUTPUT FIELDS (stable schema): - repo_url (str): canonical URL of the scanned repo. - score (int): 0-100, higher safer. Coarse summary, not a precision claim. - summary (object): {critical, high, medium, low, info, files_scanned}. - recommendation (str): action guidance derived from severity counts. - findings_count (int): total raw findings (may include false positives). - top_findings (list): up to 10 most severe, each with {id, title, severity, file, line, owasp, cwe}. - l0_discovery (object): MCP transport, tool count, dependency pinning. - performance (object): clone_seconds, scan_seconds, repo_size_bytes. - scanner (object): {name, version, layers_covered}. - _disclaimer (str): MANDATORY triage disclaimer. Read it. Args: github_url: Public GitHub HTTPS URL (e.g. https://github.com/org/repo). Must be public and < 200 MB. v1 is github.com only. Returns: Structured scan result. On error, returns {"error": code, "message": ...} with HTTP-style code (invalid_url, clone_failed, scan_timeout, etc.).
    ConnectorNo auth
  • Maps only stable Tier1 finding identifiers to approved Tier1 services and public resources. Call after a Tier1 score or email-domain check. Do not submit prose, URLs, customer information, or invented identifiers. This tool performs no arbitrary fetching, makes no contact request, changes nothing, and stores nothing.
    ConnectorNo auth
  • No arguments. Returns how many MCP servers have been read at source level, and the share of them with each category of finding (credential access, network egress, install-time execution, prompt-injection surface). Use this to judge whether checking a specific server is worth it before you look one up. It reports aggregate counts only - no per-server findings, and no verdict about any individual server.
    ConnectorNo auth
  • Start connecting GitHub for the CALLER'S OWN FindAgent account so findagent_import_repo / findagent_list_repos can pull their repos. Returns whether GitHub is already connected plus a browser connect URL — the caller opens it, authorizes GitHub, and the token is stored server-side (this tool grants nothing itself; the actual connect happens in the browser). Call this first if import_repo or list_repos reports github not connected. The connection is scoped to THIS FindAgent account, so authorize on the same browser account. To switch GitHub accounts, use findagent_disconnect_github first.
    ConnectorOAuth
  • Trigger a production deploy for one of your team's connected repositories. The repository must have a deploy trigger configured — either a deploy hook URL or a GitHub Actions workflow — in its Coderbuds settings. Identify the repository by name (e.g. "saas") or by full name (e.g. "patchstack/saas"). This ships whatever is currently merged; it is not a dry run. Use GetUndeployedPullRequestsTool first if you want to see what will go out.
    ConnectorOAuth

Matching MCP Servers

Matching MCP Connectors

  • GitHub MCP — wraps the GitHub public REST API (no auth required for public endpoints)

  • Manage repositories, users, releases, and automate GitHub workflows

  • List the secrets stored in the user's Mnemoverse Vault — by ALIAS and purpose only; the secret VALUE is never returned or shown, and no tool on this server returns it. Use this to check WHICH secrets the user has stored and under what alias (e.g. 'do I have a GitHub token saved?'). Only the caller's own secrets are listed.
    ConnectorOAuth
  • Find working SOURCE CODE examples from 42 indexed Senzing GitHub repositories. REQUIRED: either `query` (string, for search) or `repo` with `file_path` or `list_files=true` — the call WILL FAIL without one. Three modes: (1) Search: pass `query` to find examples across all repos, (2) File listing: pass `repo` + `list_files=true`, (3) File retrieval: pass `repo` + `file_path`. Indexes source code (.py, .java, .cs, .rs, .ts, .js) and READMEs — NOT build/data files. For sample data, use get_sample_data. Covers Python, Java, C# (official SDKs) plus Rust and TypeScript/Node.js (community-maintained wrappers, not official) SDK patterns: initialization, ingestion, search, redo, configuration, message queues, REST APIs. Use max_lines to limit large files. Returns GitHub raw URLs for file retrieval.
    ConnectorNo auth
  • List the GitHub repositories you have connected to Dockhold, across every installation. Call this before deploy_app when the target repo is private, or when the user asks which repos they can deploy. Each repo comes with its installation_id: pass that (with the repo's clone URL) to deploy_app to deploy a PRIVATE repository. Public repos don't need it.
    ConnectorNo auth
  • Fast deterministic preflight for tool-only clients. Call this before any other WORKS tool when eligibility is uncertain, especially for mutable or abbreviated refs, local or private repositories, and build, test, runtime, deployment, or production claims. It does not download a repository or persist data. If eligible is false, stop without calling verification.
    ConnectorNo auth
  • Fetch the complete record for ONE MCP server in the agentage directory by its canonical slug: full description, categories, the packages and remote endpoints it ships, the tools it exposes, a ready-to-run install command, and a README excerpt. Use this after mcp_search to get the depth a result card omits - pass a slug exactly as returned by mcp_search. Slugs are canonical and registry-derived ("io-github-github-github-mcp-server"), NOT the plain product name ("github"); if you pass a plain name anyway it is resolved by search as a fallback - a single confident match returns that server (with `resolved_from` set), anything else returns an error naming the candidate slugs to retry with. No slug yet? call mcp_search first. Read-only.
    ConnectorNo auth
  • List GitHub Discussions from Canton Network and Digital Asset repositories cached by CCPEDIA, sorted by recency (newest first). Filter by repo or category, or call with no filter to see which repos are present. CANTON-ONLY and read from CCPEDIA's cache, NOT the live GitHub API or the user's own repos (use a GitHub MCP for those). This is GitHub Discussions: distinct from the Canton web forum (get_discussion) and the sync.global mailing lists (list_mailing_threads). Use get_github_discussion for full body + comments.
    ConnectorNo auth
  • Read one Celestia GitHub Discussion (celestiaorg/docs and other Celestia repos) cached on THIS server — full body plus comments — by an id you got from list_github_discussions on this server. Celestia cache only: if the id was not returned by this servers list_github_discussions, or the request is just a raw GitHub node id (e.g. D_kw...) with no Celestia context, this is NOT the tool — use a dedicated GitHub tool for arbitrary GitHub Discussions. This is GitHub Discussions, not the community forum (use get_discussion). Pair it with list_github_discussions, which supplies the valid ids.
    ConnectorNo auth
  • Read a resource by its URI. For static resources, provide the exact URI. For templated resources, provide the URI with template parameters filled in. Returns the resource content as a string. Binary content is base64-encoded.
    ConnectorAPI key
  • CALL when the user is choosing between exactly two dependencies or repositories. Returns the preferred candidate for each use case, material trade-offs, confidence, and evidence gaps. Each target is owner/repo, a GitHub URL, an npm package name, or npm:@scope/pkg. Cached full analyses are preferred; a miss uses bounded live GitHub/OpenSSF evidence with limited confidence and explicit unknowns rather than guessing.
    ConnectorNo auth
  • Build a container image on Control Plane from a GitHub or GitLab repository and push it to the org's private registry. No Docker daemon is involved: the service clones the repo, detects how to build it (Dockerfile when present), and always produces linux/amd64. Returns a buildId to read with get_image_build — the build keeps running after this call returns. ONLY repositories work here. To build a LOCAL FOLDER, tell the user to run `cpln image build --remote --dir PATH --name NAME:TAG` in their terminal — this server has no access to their filesystem. Building an existing NAME:TAG replaces that image. A private repository needs a one-time browser authorization per org; this tool returns the link when that is missing. Recommended reading before first use: get_cpln_skill("image") — the runbook for this tool family (read once per session).
    Connector
    Destructive
    OAuth
  • Get the available services, prices, durations, and bookable staff or resources for a specific Korean beauty or wellness shop. Use this after finding a shop when service details, prices, durations, staff, or resources are needed before checking appointment availability. Pass lang to receive the content translated into the customer's language.
    ConnectorNo auth
  • Audit any GitHub repository and get back one complete result: a report (inventory, languages, spine files, risk signals), the capabilities found in it (name, signature, file and line, stated contract, dependencies), and how it stands against SHPBL's anonymous corpus of audited repositories. Works with no key: every caller gets the whole diagnosis of their own repository. A free run stops at the composition boundary — neither library is searched, so no library rows, candidates, parents or proposed architecture are returned — and nothing is retained (no pull request, no export, no recorded run). A Practitioner key (7-day free trial) continues past that boundary: both libraries searched, candidates identified and composed, and the result written back to your own repository. Whatever a run finds is yours. Follow with `fix_repo` for verbatim source and diffs, `harvest_repo` for the whole tree.
    ConnectorNo auth
  • Land finished work in a repository as a pull request: pass the files you wrote (full new contents, not diffs) and this opens a branch and a PR for the human to review and merge. Nothing is ever pushed to the default branch. Requires a SHPBL Practitioner key and the SHPBL GitHub App installed on that repository (or a one-off `github_token`). The caller chooses the repository — ask which one, or call `list_repos` first; never assume. Where things go: Harvest output belongs under `.shpbl/` in **the caller's own repository** — the person who asked for the run — and never in the repository that was harvested. Those are frequently not the same repository: a run may read a public open-source project, or a repository the caller merely has access to, and writing a harvest back into a source repository would be putting our output into somebody else's software. Sources a run may read: public repositories that carry a proper open-source license, the caller's own repositories, or private repositories the caller has access to. The server never reads a repository the caller has no right to read, and it never absorbs customer harvests back into the public library. - `.shpbl/README.md` — the index of their capability library (this tool scaffolds it when it is absent). - `.shpbl/<run-seal>/LEDGER.md` — the folded ledger for one run. - `.shpbl/<run-seal>/REPORT.html` — the branded report, if one was produced. - `.shpbl/<capability-name>/` — a capability kept as source, one folder each. - `.shpbl/COMPOSITES.md` — your own composites: capabilities this run invented for your repository by fusing parts that did nothing alone. Record each as `- <name> — <what it fuses> — <why neither part sufficed>`. These are yours and stay private; SHPBL's global composites ledger is fed only by Governor-keyed published runs, so never send yours anywhere and never expect them to appear there. If the harvested repository is not the caller's own, the harvest still lands in the caller's `.shpbl/` and the source is named in provenance. Ask the person which of their repositories is the home for their library if it is not obvious, and stop for that answer rather than guessing. Give each kept capability a one-line contract in `.shpbl/README.md`, in the form `- <name> — <path> — <contract>`. That index is what makes the library reusable: on the next run, read it and pass those entries as `own_library` to `evaluate_repo`, `fix_repo` or `run_gauntlet`, and the run will tell you which concerns you already solved before citing anything new. Those entries stay yours — they are held for the call and never stored by SHPBL. Repairs are the exception: write the repaired file at its own path, never under `.shpbl/`.
    ConnectorNo auth
  • POST-ACTION Wallet Secret Guardian ($0.02). Scans for BIP-39 seed phrases (12 or 24 consecutive wordlist words), raw hex or WIF-format private keys, Ethereum/Bitcoin wallet addresses, and API keys/bearer tokens appearing near wallet/custody/signing terminology. Any finding results in NO_COMMIT — wallet secrets have no safe threshold, unlike other DCL evaluators. Returns a `sanitized_output` with all matches redacted (null if nothing was found) and a masked `redacted_sample` per finding — the real value is never returned or stored server-side.
    ConnectorNo auth
  • Get remediation advice for a single finding as GitHub-flavored markdown. When AI Assist is enabled and within budget this is a suggestion written for this exact finding; otherwise it falls back to the static guidance-library text and says so in 'source'. Unlike the other reads this one can spend AI budget, which is why it is a separate tool. Use this for advice on one finding; for the whole library use list_security_guidance. Requires project context.
    ConnectorAPI key