mcpxray-cli 1.0.0__py3-none-any.whl

mcpxray/verdict.py

@@ -0,0 +1,139 @@
+"""Verdict engine — collapse findings into a plain-language safety verdict.
+
+A consumer just wants to know "can I install this MCP server?" — not a raw
+``82/100 (B)``. :func:`verdict` projects a :class:`~mcpxray.ir.McpServer`
+(plus its :class:`~mcpxray.score.ScoreResult`) onto a traffic-light tier with a
+human headline, an actionable recommendation, and the top reasons. It is a pure
+downstream view: it changes neither the score nor the rules.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from mcpxray.ir import SEVERITY_WARNING, SOURCE_STATIC
+
+if TYPE_CHECKING:
+    from mcpxray.ir import Diagnostic, McpServer
+    from mcpxray.score import ScoreResult
+
+# --- tiers -------------------------------------------------------------------
+TIER_OK = "ok"
+TIER_CAUTION = "caution"
+TIER_DANGER = "danger"
+TIER_UNKNOWN = "unknown"
+TIERS = (TIER_OK, TIER_CAUTION, TIER_DANGER, TIER_UNKNOWN)
+
+# rule_id -> one short, plain-language phrase shown to the user.
+_RULE_PHRASE = {
+    "MCP101": "Possible tool-poisoning in a tool description",
+    "MCP102": "Leaked secrets/keys in source",
+    "MCP103": "Dangerous code execution (eval/exec/shell)",
+    "MCP104": "Weak or empty input schemas",
+    "MCP105": "Schema/handler drift (declared vs actual params)",
+    "MCP106": "JSON-Schema incompatibilities (may break Cursor/ChatGPT)",
+    "MCP107": "Tool descriptions need cleanup",
+    "MCP108": "Unpinned dependencies (supply-chain risk)",
+    "MCP109": "Insecure network transport (no TLS/auth)",
+}
+
+# Display order for reasons: scariest first so the top of the card leads with
+# RCE / secrets / poisoning rather than a hygiene warning.
+_RULE_PRIORITY = {
+    "MCP103": 0,
+    "MCP102": 1,
+    "MCP101": 2,
+    "MCP108": 3,
+    "MCP104": 4,
+    "MCP106": 5,
+    "MCP107": 6,
+    "MCP105": 7,
+    "MCP109": 8,
+}
+
+_MAX_REASONS = 5
+
+
+@dataclass(frozen=True)
+class Reason:
+    """One line of the 'Why' block: a rule, its plain phrase, and its count."""
+
+    rule_id: str
+    phrase: str
+    count: int
+
+
+@dataclass(frozen=True)
+class Verdict:
+    """The consumer-facing outcome of checking a server."""
+
+    tier: str
+    headline: str
+    recommendation: str
+    reasons: list[Reason] = field(default_factory=list)
+
+
+def _reasons(diags: list[Diagnostic]) -> list[Reason]:
+    """Group diagnostics by rule_id, order scariest-first, cap at ``_MAX_REASONS``."""
+    counts: dict[str, int] = {}
+    for d in diags:
+        counts[d.rule_id] = counts.get(d.rule_id, 0) + 1
+    ordered = sorted(counts, key=lambda r: (_RULE_PRIORITY.get(r, 99), r))
+    return [
+        Reason(rule_id=r, phrase=_RULE_PHRASE.get(r, r), count=counts[r])
+        for r in ordered[:_MAX_REASONS]
+    ]
+
+
+def verdict(doc: McpServer, score_result: ScoreResult | None = None) -> Verdict:  # noqa: ARG001
+    """Project a server onto a consumer-facing :class:`Verdict`.
+
+    Tier rules (checked in order):
+
+    * **unknown** — static source with zero tools extracted (a language mcpxray
+      doesn't parse, or a tree with no tool registrations). A manifest/runtime
+      capture with zero tools is *not* unknown: the user handed it to us
+      deliberately, so "couldn't check" would be misleading.
+    * **danger** — any ERROR-severity finding (poisoning / secrets / RCE).
+    * **caution** — no errors, but at least one WARNING.
+    * **ok** — nothing found.
+    """
+    if doc.source_mode == SOURCE_STATIC and not doc.tools:
+        return Verdict(
+            tier=TIER_UNKNOWN,
+            headline="Couldn't verify statically",
+            recommendation=(
+                "Couldn't verify statically; review manually, capture the server's "
+                "tools/list and re-run with --manifest, or use --runtime --command "
+                "to let mcpxray capture it live."
+            ),
+        )
+
+    if doc.has_errors:
+        return Verdict(
+            tier=TIER_DANGER,
+            headline="Do not install this server",
+            recommendation=(
+                "This server has critical issues; do not install it. "
+                "Fix the issues above or pick a different server."
+            ),
+            reasons=_reasons(doc.errors),
+        )
+
+    warnings = [d for d in doc.diagnostics if d.severity == SEVERITY_WARNING]
+    if warnings:
+        reasons = _reasons(warnings)
+        top = ", ".join(r.phrase for r in reasons[:3])
+        return Verdict(
+            tier=TIER_CAUTION,
+            headline="Use with caution",
+            recommendation=f"Usable, but be aware of: {top}.",
+            reasons=reasons,
+        )
+
+    return Verdict(
+        tier=TIER_OK,
+        headline="Looks clean",
+        recommendation="Looks clean, safe to add to Claude Code.",
+    )

mcpxray_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.3
+Name: mcpxray-cli
+Version: 1.0.0
+Summary: Static linter + 0-100 scorecard for MCP servers. Catches tool poisoning, secret leaks, schema drift and more — locally, deterministically, in CI.
+Author: Mitia
+Author-email: Mitia <mitia@cloudroad.io>
+Requires-Dist: typer>=0.12
+Requires-Dist: pyyaml>=6
+Requires-Dist: tomli>=2 ; python_full_version < '3.11'
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# mcpxray
+
+**Static linter + 0–100 scorecard for MCP servers.** `mcpxray` scans an MCP server's source (or a captured `tools/list` manifest) and flags tool poisoning, leaked secrets, dangerous capabilities, weak schemas and more — **locally, deterministically, in CI**. Point it at a GitHub URL or a local path and get a plain-language verdict — 🟢 ok / 🟡 caution / 🔴 danger — plus a 0–100 score and an SVG badge.
+
+> MCP is the fastest-growing dev protocol since GraphQL (~97M SDK downloads/month), yet 7%+ of servers ship with vulnerabilities and the OWASP MCP Top 10 is a list, not a tool. `mcpxray` is the missing `npm audit` + OpenSSF Scorecard for MCP — static, local-first, OSS.
+
+## Status
+
+✅ **v1.0.0** — stable public API. Python + TypeScript static extractors, manifest extractor, opt-in runtime `tools/list` capture, rules **MCP101–109** (full OWASP MCP Top-10 mapping), `check`/`scan`/`score`/`badge`/`version`, plain/json/github/sarif/card reports, 0–100 score with error cap, SVG badge, `--fix`/`--diff` for MCP108, pre-commit hook, frozen plugin API (`__all__` + SemVer policy), tokenless PyPI trusted publishing. 224 tests.
+
+## Install
+
+```bash
+uv tool install mcpxray-cli
+# or: pip install mcpxray-cli
+```
+
+The PyPI distribution is `mcpxray-cli` (the name `mcpxray` is blocked on PyPI by an unrelated project); the command it installs is still `mcpxray`.
+
+Requires Python ≥ 3.10.
+
+## Quick start
+
+```bash
+# Is this MCP server safe to install? Point mcpxray at a GitHub URL or a local path.
+mcpxray check https://github.com/owner/repo
+mcpxray check path/to/my-mcp-server
+
+# Verdict + the full finding list
+mcpxray check path/to/my-mcp-server --details
+
+# Not a Python server? Hand mcpxray a captured tools/list dump (any language)
+mcpxray check --manifest tools-list.json
+
+# ...or spawn the server and let mcpxray capture tools/list live (any language)
+mcpxray check --runtime --command "python -m my_mcp_server"
+
+# --- power users / CI -----------------------------------------------------
+# Lint and print findings (CI gate: --check exits 1 on any ERROR)
+mcpxray scan path/to/my-mcp-server --check -f github
+# Just the 0–100 score, fail below a bar
+mcpxray score path/to/my-mcp-server --fail-under 80
+# Embed an SVG score badge in your README
+mcpxray badge path/to/my-mcp-server -o docs/score.svg
+```
+
+## Commands
+
+| Command | Purpose |
+| --- | --- |
+| `mcpxray check <URL \| PATH> [--manifest FILE] [--runtime --command CMD] [--details\|-v] [--fail-under N]` | **Friendly safety verdict** (🟢/🟡/🔴/⚪) + recommendation. Clones a GitHub URL automatically; exits 1 on 🔴 danger or below `--fail-under`. |
+| `mcpxray scan [PATH] [--manifest FILE] [--runtime --command CMD] [-f plain\|json\|github\|sarif\|card] [--check] [--fix] [--diff]` | Lint a server and print findings. `--check` exits 1 on any ERROR (CI gate); `--fix` pins unpinned deps in place, `--diff` previews (local source only). |
+| `mcpxray score [PATH] [--manifest FILE] [--runtime --command CMD] [--fail-under N]` | Print the 0–100 score and grade; exit 1 below `--fail-under`. |
+| `mcpxray badge [PATH \| --score N] [-o FILE]` | Render an SVG score badge (`-o -` for stdout). |
+| `mcpxray version` | Print the version. |
+
+## What the verdict means
+
+`mcpxray check` turns findings into a traffic-light verdict instead of a raw score:
+
+| Verdict | When | Exit | What to do |
+| --- | --- | --- | --- |
+| 🟢 **OK** | nothing found | 0 | Safe to add to Claude Code. |
+| 🟡 **CAUTION** | no errors, but warnings (weak schemas, unpinned deps, …) | 0 | Usable — mind the listed weaknesses. |
+| 🔴 **DANGER** | any error (tool poisoning, leaked secrets, RCE) | 1 | **Do not install.** |
+| ⚪ **UNKNOWN** | no MCP tools found statically (unsupported language, or tools built at runtime) | 0 | Can't check statically — capture `tools/list` (`--manifest`) or spawn the server (`--runtime --command`). |
+
+The numeric score (0–100, shown as a secondary detail) still follows the error-cap rule below: any error caps it at 60. `--fail-under N` adds a CI gate that is independent of the verdict (it can turn a 🟡/🟢 into an exit-1 without changing the displayed verdict).
+
+> **Languages:** mcpxray checks **Python and TypeScript** statically (FastMCP `@mcp.tool` and the TS SDK's `server.tool(...)` / `registerTool(...)` / low-level `ListToolsRequestSchema` shapes). Servers in other languages — or tools built dynamically at runtime — still return ⚪ UNKNOWN; capture `tools/list` (`mcpxray check --manifest dump.json`), or spawn the server and let mcpxray capture it live (`mcpxray check --runtime --command '<launch>'`).
+
+## Runtime capture (`--runtime --command`)
+
+When source isn't parseable (compiled, 3rd-party, or tools built dynamically), `--runtime` **spawns the server, performs the MCP JSON-RPC handshake over stdio (`initialize` → `notifications/initialized` → `tools/list`), and feeds the captured tools through the same rules**. It's strictly opt-in and needs an explicit launch command:
+
+```bash
+mcpxray check --runtime --command "python -m my_mcp_server"
+mcpxray check --runtime --command "node dist/index.js" path/to/server   # cwd = the path
+```
+
+> ⚠️ **`--runtime` executes the server under inspection.** It is opt-in, runs the server with a bounded lifetime (timeouts + guaranteed teardown), and parses its response defensively — but provides **no OS-level sandbox** (no filesystem/network isolation). Only point it at servers you trust; for untrusted servers, run mcpxray inside a container or VM. Prefer `--manifest` when you already have a captured `tools/list`.
+
+Runtime-captured tools carry no source text, so the source-scanning rules (MCP102 secrets / MCP103 RCE / MCP105 drift / MCP109 transport) can't fire — but schema and description rules (MCP104/106/107) still run on the captured definitions.
+
+## Auto-fix (`scan --fix` / `--diff`)
+
+The one rule that's mechanically, unambiguously fixable is **MCP108** (unpinned dependencies): `scan --fix` pins a floating spec to its concrete floor version — `requests>=2.30.0` → `requests==2.30.0` (pip), `"zod": "^1.2.3"` → `"zod": "1.2.3"` (npm). It edits `pyproject.toml` / `package.json` in place (atomically); `--diff` prints the same changes as a unified diff and writes nothing.
+
+```bash
+mcpxray scan path/to/server --diff     # preview (exits 1 if changes are pending — CI-friendly)
+mcpxray scan path/to/server --fix      # apply in place
+```
+
+What it does **not** touch:
+
+- **No floor to pin** (`*`, `latest`, a bare `flask`, `>=2` with no patch) → skipped, left for you to resolve against a registry. mcpxray never invents a version.
+- **Specs with extras/env markers** (`pkg[extra]>=1.2.3`, `pkg>=1.2.3 ; python_version>'3'`) → skipped (rewriting them textually is unsafe).
+- **Every other rule** (MCP101–107, MCP109) → not auto-fixable; these need human judgment (a leaked secret isn't "fixed" by deleting it).
+
+`--fix`/`--diff` are **static-source-only** — they rewrite files in place, so they reject `--manifest`, `--runtime`, and URL targets (point them at a local path). Every edit is a literal, uniquely-anchored replacement, so an ambiguous match is skipped rather than applied wrongly. Re-run `scan` after `--fix` to confirm the score improved.
+
+## Rules
+
+Each finding is a `Diagnostic` with a severity (`error`/`warning`/`info`). **Any `error` caps the score at 60**, so a leaked secret or poisoned tool can never be diluted into a green grade.
+
+| ID | OWASP MCP | Rule | Severity |
+| --- | --- | --- | --- |
+| MCP101 | Tool Poisoning | hidden instructions in a tool `description` ("ignore previous", exfiltrate-to-URL, hidden format/bidi chars) | error |
+| MCP102 | Token/Secret Exposure | secrets/tokens/API keys in source (regex: private keys, `sk-`, AWS, GitHub, GitLab, Slack, Google, hardcoded creds) | error |
+| MCP103 | Excess Permissions (MCP04) | dangerous capabilities: `os.system`, `eval`/`exec`, `pickle.loads`, `subprocess(..., shell=True)` | error |
+| MCP104 | — (hygiene) | weak schema: no `required`, or a property with an empty `{}` schema | warning |
+| MCP105 | — (correctness) | schema/implementation drift: a tool's declared `inputSchema` disagrees with its handler's parameters | warning |
+| MCP106 | — (compat) | JSON-Schema incompatibilities that break Cursor/ChatGPT (`$ref`/`oneOf`/`anyOf`/`allOf`, missing `type`) | warning |
+| MCP107 | — (context) | missing or oversized `description` (eats the model's context budget) | warning |
+| MCP108 | Supply-Chain (MCP05) | unpinned dependencies with no lockfile (pip **and** npm — `^`/`~`/`>=`/`*` drift) | warning |
+| MCP109 | — (transport) | HTTP/SSE transport exposed without TLS or authentication | warning |
+
+## Score & grades
+
+| Grade | Score | Meaning |
+| --- | --- | --- |
+| **A** | 90–100 | Clean |
+| **B** | 80–89 | Minor warnings |
+| **C** | 70–79 | Some hygiene debt |
+| **D** | 60–69 | Serious — errors present (capped) |
+| **F** | 0–59 | Critical — errors present (capped) |
+
+Deductions: `error` = −20, `warning` = −6, `info` = −1, clamped to `[0, 100]`.
+
+## CI
+
+```yaml
+# .github/workflows/mcp.yml
+name: mcpxray
+on: [push, pull_request]
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv tool install mcpxray-cli
+      # GitHub annotations + SARIF-friendly; fails on any ERROR
+      - run: mcpxray scan ./src --check -f github
+      # Optional: fail below a score bar
+      - run: mcpxray score ./src --fail-under 80
+```
+
+## Pre-commit hook
+
+Lint on every commit from any MCP-server repo. Add `mcpxray` to your `.pre-commit-config.yaml`:
+
+```yaml
+repos:
+  - repo: https://github.com/cloudroad-io/mcpxray
+    rev: v1.0.0          # pin to a release tag
+    hooks:
+      - id: mcpxray
+        args: ["./src"]  # path to your server source
+```
+
+The hook runs `mcpxray scan --check <path>` and fails the commit on any ERROR (tool poisoning, leaked secrets, RCE). Requires the `mcpxray-cli` distribution on PyPI; if you install it locally instead (`uv tool install mcpxray-cli`), set `language: system` on the hook.
+
+## How it works
+
+1. **Extract.** `PythonExtractor` walks `.py` files, finds `@mcp.tool` / `@server.tool` decorators, and lifts `name`, the docstring (→ `description`) and type hints (→ JSON Schema) straight from the AST — **no imports, no execution**. `ManifestExtractor` parses a captured `tools/list` JSON dump for servers in any language. For servers you can run, `--runtime --command` spawns it and captures `tools/list` live (`runtime.py`).
+2. **Lint.** Each rule sees the resulting `McpServer` IR and emits `Diagnostic`s.
+3. **Score.** Findings collapse to a 0–100 score with an error cap (mirrors OpenSSF Scorecard's shape).
+4. **Report.** `plain`, `json`, `github` annotations, or `sarif` (for GitHub code scanning).
+
+See [ARCHITECTURE.md](ARCHITECTURE.md) for the full pipeline and [CONTRIBUTING.md](CONTRIBUTING.md) to add a rule or extractor in one file.
+
+## Why mcpxray
+
+- **Static, not runtime.** No need to start the server or trust what it reports at runtime — parse definitions from source. Deterministic and CI-safe.
+- **MCP-semantic.** Knows about tool poisoning, schema compatibility, over-permissive tools — things generic SAST and OpenSSF Scorecard can't see.
+- **Source-level locations.** Findings point at `file:line`, not anonymous runtime entries.
+- **Plugin-friendly.** Add a rule or an extractor by subclassing + one decorator. Entry-points let external packages extend `mcpxray` without forking.
+
+## Dogfood
+
+Scanned against the official [`modelcontextprotocol/python-sdk`](https://github.com/modelcontextprotocol/python-sdk) example servers:
+
+| Server | Score | Findings |
+| --- | --- | --- |
+| `everything-server` | **82/100 (B)** | 3 warnings — an untyped `region` param, an all-optional schema, unpinned deps |
+| `examples/mcpserver` | **58/100 (F)** | 7 warnings — missing descriptions, untyped Pydantic-model params |
+
+(FastMCP's framework-injected `ctx: Context` parameter is correctly excluded from every tool's schema — the same way the SDK itself does it — so it doesn't generate noise.)
+
+## Roadmap
+
+- **v0.2** — scope URL clones to the server entry point, TypeScript static extractor, rules MCP105/109, opt-in runtime `tools/list` capture (`--runtime --command`). ✅ shipped.
+- **v1.0** — frozen plugin API (SemVer), `--fix`/`--diff`, pre-commit hook, GitHub Actions CI, PyPI trusted publishing. ✅ shipped (v1.0.0).
+- **Later** (needs external services/accounts): hosted badge API + leaderboard (hosting), registry integrations (Glama/Smithery API keys). Full history: [`docs/v0.2-plan.md`](docs/v0.2-plan.md).
+
+## License
+
+MIT.

mcpxray_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+mcpxray/__init__.py,sha256=nZYWjUiRg1eHxR3iZ6PH1GxzhvZLOA5joY8KUl_Aaos,758
+mcpxray/__main__.py,sha256=CyHBzis7Y1UWrNvxxww5mh4x640tNWNfM2pcfKVuiO0,110
+mcpxray/badge.py,sha256=zqaLDq3l09KakghyO75JpIilWJTIIpqDF3McJ-uuyy4,1727
+mcpxray/cli.py,sha256=SrSiJajR-RWm0WuwEg-CPl-7A01q1yzOBWnQC2hX8Zw,11950
+mcpxray/extract/__init__.py,sha256=HT7wYQraJdo5pzOAhQC_8Rzu6X984CrYBZVKezyBQQM,614
+mcpxray/extract/base.py,sha256=_jF7N7yTzjgMYXQ9eL0jQboYtga-YP0FHlMefaQRmwA,2105
+mcpxray/extract/manifest.py,sha256=xJ0Iz2KjjyD3GNqyaRgz-iFqG8LJFbS3QNN6lXhXKx4,3286
+mcpxray/extract/python_static.py,sha256=EfTX-uqeGxmPcWDyBpV9yoLRIH5FZ2jVjkPBg4yaXOE,10946
+mcpxray/extract/typescript_static.py,sha256=F9EcvJwmXRqDG13GzLmBFWcHwVjQ4S_vgZA5p4m7Fbc,19346
+mcpxray/fix.py,sha256=w8o7og8Orsi_jYquGpHhA5TUVuvAP5qGfVRj80nHw_U,6085
+mcpxray/ir.py,sha256=LPv_FDLcKKro7wkYYpf0yI18XqnTqkjPvzac-40t_Co,5893
+mcpxray/report/__init__.py,sha256=D-6g56VCC_qEJTGce_q_enemhTbPn-S8BlWS0natjmM,1327
+mcpxray/report/card.py,sha256=MlpmGSiLmxeyJqbkjyHHPsV_GX2xJAWktwGsIUA7N-U,4657
+mcpxray/report/github.py,sha256=fvHMAnO0hPOV-l3jbOuWMuhDQZPL7qga8kVezhNF9Hw,927
+mcpxray/report/json.py,sha256=oYm8ZxhSJabxdBEVrokptrboCLxcRFFDD6-JEqRMFhk,1371
+mcpxray/report/plain.py,sha256=on3CsEKHmIPoZ8mqEhAcZTgHCbnNOqYstBBOU9vWTU4,1149
+mcpxray/report/sarif.py,sha256=J5kome8-GESOM0cj4VNcf11RQLeAMsfJajDVb63UN3o,2225
+mcpxray/rules/__init__.py,sha256=flv_Y2l0OWoiQyGvaPDp7j8dR7dcFLCK9BeFV6ovRbU,272
+mcpxray/rules/base.py,sha256=M70ADgZUToifmVcO-xDf3dwgQYnb4e6US5_lsIrH7zQ,2060
+mcpxray/rules/builtin/__init__.py,sha256=6cAvmmZuubIJMGb2G9mD6hyK0wMW2wLv2LcN45bY0TA,204
+mcpxray/rules/builtin/descriptions.py,sha256=R9wi8IffiksrUjF7ymyYufkmuzlejX_F9sS31QtfcRg,3782
+mcpxray/rules/builtin/schema.py,sha256=SJrBR3FXqWmNvACBcvRP4TMQe2zxhvjFc96ByfeOpTo,4572
+mcpxray/rules/builtin/source.py,sha256=Lc6cTDoEz1Y-jIU2IHDMLKRjh1ziRpsZ1ssxck-l368,3455
+mcpxray/rules/builtin/supply.py,sha256=gHGOVM-C9-NIp0Mjhipdfmt1lbDwHogvtui3gGWURes,3613
+mcpxray/rules/builtin/transport.py,sha256=BZPoGbZIGuH7ydNL8lZMPA1K5ycOUtEnw5Z8QVSj8g8,2992
+mcpxray/runtime.py,sha256=b37G3xN8dndHJ4q2NL-tmcbu1RyZP5rfXrN_FREDXW0,9445
+mcpxray/score.py,sha256=5057bBxBjMO5uQ40qLTzjbFa2MVMRDZ1yhaq8p3rqZU,2096
+mcpxray/source.py,sha256=v-yiXCuou01DpBhoIsGhRlKwwgMLUnAdaABw2nH2MpE,10234
+mcpxray/verdict.py,sha256=UtxVsDzYKFJHV_luGP6BONLHsS2AyAquKH6CzpG_JCk,4747
+mcpxray_cli-1.0.0.dist-info/WHEEL,sha256=4OL6Foqnnp3xRY5wMkjgc25_i5YJC6dKsC6LPcjqEoU,80
+mcpxray_cli-1.0.0.dist-info/entry_points.txt,sha256=3SdLEVCPDwyDhHRvzjvUFl-ecAiLhktfMxEq1_HAEV0,84
+mcpxray_cli-1.0.0.dist-info/METADATA,sha256=lDgyiZq3rmLHjLOBd_f1DNwAn8M1ZErjkmG4KeLVB8Q,13207
+mcpxray_cli-1.0.0.dist-info/RECORD,,

mcpxray_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.5
+Root-Is-Purelib: true
+Tag: py3-none-any

mcpxray_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+mcpxray = mcpxray.cli:app
+
+[mcpxray.extractors]
+
+[mcpxray.rules]
+