mcpprobe-scanner 0.1.0__py3-none-any.whl

mcpprobe/transport/stdio.py

@@ -0,0 +1,201 @@
+"""stdio transport: spawn a local MCP server command and speak newline-delimited JSON-RPC.
+
+Only use this on packages you run yourself. The scanner does not sandbox the
+child process; see SANDBOX-01 in CHECKS.md for the planned sandboxed runner.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shlex
+import time
+from collections import deque
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from mcpprobe.transport.base import RpcResponse, Transport, TransportError
+from mcpprobe.transport.evidence import EvidenceLog
+from mcpprobe.transport.ratelimit import RateLimiter
+
+STDERR_TAIL_LINES = 200
+#: Protect against a server that floods stdout with one enormous line.
+MAX_LINE_BYTES = 10_000_000
+
+
+class StdioTransport(Transport):
+    """Child-process MCP server driven over stdin/stdout."""
+
+    name = "stdio"
+
+    def __init__(
+        self,
+        command: str | Sequence[str],
+        *,
+        env: Mapping[str, str] | None = None,
+        cwd: str | None = None,
+        timeout: float = 15.0,
+        evidence: EvidenceLog | None = None,
+        limiter: RateLimiter | None = None,
+        inherit_env: bool = True,
+    ) -> None:
+        super().__init__(evidence=evidence, limiter=limiter)
+        self.argv: list[str] = list(shlex.split(command) if isinstance(command, str) else command)
+        if not self.argv:
+            raise TransportError("empty stdio command")
+        self.env = dict(env or {})
+        self.cwd = cwd
+        self.timeout = timeout
+        self.inherit_env = inherit_env
+        self.proc: asyncio.subprocess.Process | None = None
+        self.stderr_tail: deque[str] = deque(maxlen=STDERR_TAIL_LINES)
+        self._pending: dict[int | str, asyncio.Future[dict[str, Any]]] = {}
+        self._reader_task: asyncio.Task[None] | None = None
+        self._stderr_task: asyncio.Task[None] | None = None
+        self.unsolicited: list[dict[str, Any]] = []
+
+    @property
+    def display(self) -> str:
+        return " ".join(shlex.quote(a) for a in self.argv)
+
+    async def start(self) -> None:
+        if self.proc is not None:
+            return
+        env = dict(os.environ) if self.inherit_env else {}
+        env.update(self.env)
+        try:
+            self.proc = await asyncio.create_subprocess_exec(
+                *self.argv,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env=env,
+                cwd=self.cwd,
+                limit=MAX_LINE_BYTES,
+            )
+        except (OSError, ValueError) as exc:
+            raise TransportError(f"cannot start {self.display}: {exc}") from exc
+        self._reader_task = asyncio.create_task(self._read_stdout())
+        self._stderr_task = asyncio.create_task(self._read_stderr())
+
+    async def _read_stdout(self) -> None:
+        assert self.proc and self.proc.stdout
+        while True:
+            try:
+                line = await self.proc.stdout.readline()
+            except (ValueError, asyncio.LimitOverrunError):
+                self.stderr_tail.append("[mcpprobe] stdout line exceeded limit; dropped")
+                continue
+            if not line:
+                break
+            text = line.decode("utf-8", errors="replace").strip()
+            if not text:
+                continue
+            try:
+                msg = json.loads(text)
+            except ValueError:
+                self.stderr_tail.append(f"[non-JSON stdout] {text[:200]}")
+                continue
+            if isinstance(msg, dict) and "id" in msg and ("result" in msg or "error" in msg):
+                fut = self._pending.pop(msg["id"], None)
+                if fut and not fut.done():
+                    fut.set_result(msg)
+                    continue
+            self.unsolicited.append(msg if isinstance(msg, dict) else {"raw": msg})
+        for fut in self._pending.values():
+            if not fut.done():
+                fut.set_exception(TransportError("server closed stdout"))
+        self._pending.clear()
+
+    async def _read_stderr(self) -> None:
+        assert self.proc and self.proc.stderr
+        while True:
+            try:
+                line = await self.proc.stderr.readline()
+            except (ValueError, asyncio.LimitOverrunError):
+                continue
+            if not line:
+                break
+            self.stderr_tail.append(line.decode("utf-8", errors="replace").rstrip())
+
+    async def send_raw(
+        self, text: str, *, label: str, want_id: int | str | None, note: str | None = None
+    ) -> RpcResponse:
+        """Write one line to the child's stdin and (optionally) await a reply."""
+        await self.start()
+        assert self.proc and self.proc.stdin
+        await self.limiter.acquire()
+        fut: asyncio.Future[dict[str, Any]] | None = None
+        if want_id is not None:
+            fut = asyncio.get_running_loop().create_future()
+            self._pending[want_id] = fut
+        started = time.monotonic()
+        error_text: str | None = None
+        message: dict[str, Any] | None = None
+        try:
+            self.proc.stdin.write(text.encode("utf-8") + b"\n")
+            await self.proc.stdin.drain()
+            if fut is not None:
+                message = await asyncio.wait_for(fut, self.timeout)
+        except TimeoutError:
+            error_text = "timeout waiting for response"
+            self._pending.pop(want_id, None)  # type: ignore[arg-type]
+        except (BrokenPipeError, ConnectionResetError, TransportError) as exc:
+            error_text = f"{type(exc).__name__}: {exc}"
+        elapsed_ms = (time.monotonic() - started) * 1000
+        body = json.dumps(message).encode("utf-8") if message is not None else b""
+        rec = self.evidence.record(
+            transport="stdio",
+            method=label,
+            url=self.display,
+            request_body=text,
+            response_body=body,
+            elapsed_ms=elapsed_ms,
+            note=note,
+            error=error_text,
+        )
+        return RpcResponse(
+            method=label,
+            status=None,
+            headers={},
+            body=body,
+            message=message,
+            evidence=rec,
+            elapsed_ms=elapsed_ms,
+            error_text=error_text,
+            stream_messages=[message] if message else [],
+        )
+
+    async def rpc(
+        self,
+        method: str,
+        params: dict[str, Any] | None = None,
+        *,
+        note: str | None = None,
+        protocol_version: str | None = None,
+        **kwargs: Any,
+    ) -> RpcResponse:
+        msg = self.build_message(method, params, protocol_version=protocol_version)
+        return await self.send_raw(json.dumps(msg), label=method, want_id=msg["id"], note=note)
+
+    async def notify(self, method: str, params: dict[str, Any] | None = None) -> None:
+        msg = self.build_message(method, params, notification=True)
+        await self.send_raw(json.dumps(msg), label=method, want_id=None, note="notification")
+
+    async def close(self) -> None:
+        if self.proc is None:
+            return
+        try:
+            if self.proc.stdin:
+                self.proc.stdin.close()
+            try:
+                await asyncio.wait_for(self.proc.wait(), 2.0)
+            except TimeoutError:
+                self.proc.kill()
+                await self.proc.wait()
+        finally:
+            for task in (self._reader_task, self._stderr_task):
+                if task:
+                    task.cancel()
+            self.proc = None

mcpprobe_scanner-0.1.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.5
+Name: mcpprobe-scanner
+Version: 0.1.0
+Summary: Security scanner for Model Context Protocol (MCP) servers: auth, transport, tool-metadata and poisoning checks with JSON and SARIF output.
+Project-URL: Homepage, https://mcpprobe.tech
+Project-URL: Scanning policy, https://mcpprobe.tech/scanning-policy
+Project-URL: Source, https://github.com/mcpprobe-dev/mcpprobe
+Project-URL: Issues, https://github.com/mcpprobe-dev/mcpprobe/issues
+Author-email: mcpprobe contributors <hello@mcpprobe.tech>
+Maintainer-email: mcpprobe contributors <hello@mcpprobe.tech>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: mcp,model-context-protocol,owasp,sarif,scanner,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1
+Requires-Dist: dnspython>=2.6
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.6
+Requires-Dist: pyjwt>=2.8
+Requires-Dist: rich>=13.7
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# mcpprobe
+
+Security scanner for [Model Context Protocol](https://modelcontextprotocol.io) servers.
+It checks authentication, OAuth metadata, transport conformance, tool-description
+poisoning, rug pulls, secrets in metadata, verbose errors and basic resource limits,
+maps every finding to the OWASP MCP, Agentic and LLM Top 10 lists, and writes JSON,
+SARIF 2.1.0 and a readable terminal summary.
+
+It runs locally, sends no telemetry, and never calls a tool in its default mode.
+
+> **Only scan servers you own or are explicitly authorised to test.**
+> See [Ownership rule](#ownership-rule).
+
+## 60-second quickstart
+
+```console
+$ pipx run --spec mcpprobe-scanner mcpprobe https://your-server.example/mcp
+```
+
+or install it:
+
+```console
+$ pipx install mcpprobe-scanner    # or: pip install mcpprobe-scanner; the command is `mcpprobe`
+$ mcpprobe https://your-server.example/mcp --sarif mcpprobe.sarif --json mcpprobe.json
+```
+
+A local stdio server you run yourself:
+
+```console
+$ mcpprobe --stdio "npx -y @your-scope/your-mcp-server@1.2.3"
+```
+
+Passing a bearer token you own (for checks behind your auth):
+
+```console
+$ mcpprobe https://your-server.example/mcp --header "Authorization: Bearer $MCP_TEST_TOKEN"
+```
+
+The summary lists each finding with severity, check ID, confidence, OWASP mapping,
+an evidence excerpt and a plain-English fix, followed by a coverage table showing
+which checks ran, which were skipped and why. `mcpprobe checks` lists every check;
+[CHECKS.md](CHECKS.md) documents them in full.
+
+## What it checks
+
+| Area | Checks | Examples |
+|---|---|---|
+| Authentication | AUTH-01..04 | endpoint answers without credentials; missing RFC 9728 protected-resource metadata; no PKCE S256; accepts a self-minted JWT with the wrong audience; token accepted in the query string |
+| Transport | TRANS-01..05 | `Origin` not validated (DNS rebinding); bogus `MCP-Protocol-Version` accepted; weak or forgeable `Mcp-Session-Id`; deprecated HTTP+SSE; plain HTTP, weak TLS, missing headers |
+| Tool metadata | META-01..05 | hidden instructions, cross-tool shadowing, credential paths, URLs, base64, zero-width/bidi/homoglyph Unicode; rug-pull diff against a stored SHA-256 baseline; annotations that contradict capability; schema hygiene; secrets in descriptions or stdio env |
+| Robustness | ERR-01, DOS-01 | stack traces and versions in errors; one oversized argument, one 64-deep nesting probe and 20 paced `tools/list` calls, never more |
+| Active (gated stubs) | INJ-01..05, SUPPLY-01/02, SANDBOX-01 | registered and reported as `not_implemented` in this release |
+| Governance | GOV-01..05 | listed as attestation-only: not assessable by a scan, never marked passed |
+
+Protocol revisions: the scanner tries `server/discover` (2026-07-28) first, then
+`initialize` with 2025-11-25 and 2025-06-18, then the deprecated 2024-11-05 HTTP+SSE
+transport, and records which one answered.
+
+## Passive vs active
+
+**Passive (default)** sends only what a normal MCP client sends (negotiation, the
+`*/list` methods, well-known metadata documents) plus a handful of benign malformed
+requests (bad `Origin`, bogus version header, forged session ID, self-minted
+wrong-audience JWT, truncated JSON, one oversized and one deeply nested request). It
+never calls a tool.
+
+**Active** (`--active`) is for checks that call tools with non-destructive canaries.
+In 0.1.0 these are stubs, but the gate is real and enforced in code. Active mode is
+refused unless you pass all of:
+
+- `--authorised-by "<who approved this, e.g. name/role/ticket>"`
+- `--scope "<what is in scope>"`
+- `--verify dns-txt` (HTTP targets) or `--verify local` (stdio servers you run yourself)
+
+For `dns-txt`, generate a token and publish it:
+
+```console
+$ mcpprobe token your-server.example
+Publish this DNS TXT record, then run with --active --verify dns-txt:
+  _mcpprobe.your-server.example.  TXT  "mcpprobe-verification=<token>"
+$ mcpprobe https://your-server.example/mcp --active --verify dns-txt \
+    --authorised-by "platform security, CHG-1234" --scope "https://your-server.example/mcp" \
+    --json scan.json
+```
+
+Every active run writes an authorisation record (`scan.authorisation.json` next to the
+report): who authorised it, the scope, the verification proof, rate cap and excluded
+tools. Use `--exclude-tool NAME` for tools that must never be called.
+
+## Ownership rule
+
+Scan only MCP servers you own, operate, or have explicit written permission to test.
+This applies to passive mode too: even benign requests are unauthorised access if
+the system is not yours. mcpprobe identifies itself on every request and honours
+opt-outs (below), but those are courtesy mechanisms, not permission.
+
+## Scanner identification, opt-out and rate limits
+
+- User-Agent: `mcpprobe/<version> (+https://mcpprobe.tech/scanning-policy)`.
+- Opt-out, checked before any MCP request and impossible to override:
+  - DNS TXT `mcpprobe-opt-out=all` at `_mcpprobe.<host>` (or a parent domain), checked
+    before any packet reaches the host;
+  - an HTTP `200` at `/.well-known/mcpprobe-opt-out`.
+- Rate: 5 requests/second by default (`--rate`), hard ceiling 10.
+
+## Exit codes
+
+| Code | Meaning |
+|---|---|
+| `0` | No finding at or above `--fail-on` (default `high`) |
+| `1` | At least one finding at or above `--fail-on` |
+| `2` | Error: target unreachable or not MCP, bad arguments, ownership verification failed, authorisation refused, or the target opted out |
+
+## SARIF and GitHub code scanning
+
+As a GitHub Action (Docker container action, no Python setup needed):
+
+```yaml
+name: MCP security
+on: [push, pull_request]
+permissions:
+  contents: read
+  security-events: write
+jobs:
+  mcpprobe:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: mcpprobe-dev/mcpprobe@v0.1.0
+        with:
+          target: https://staging.your-server.example/mcp
+          fail-on: high
+          sarif-output: mcpprobe.sarif
+          sarif-location: src/server.py   # optional: anchor alerts to a repo file
+      - uses: github/codeql-action/upload-sarif@v3
+        if: always()
+        with:
+          sarif_file: mcpprobe.sarif
+          category: mcpprobe
+```
+
+Or from any CI with the CLI:
+
+```console
+$ pipx run --spec mcpprobe-scanner mcpprobe https://staging.your-server.example/mcp --sarif mcpprobe.sarif --fail-on high
+```
+
+Results use `error` for critical/high, `warning` for medium and `note` for low/info,
+with GitHub's `security-severity` on each rule and the OWASP IDs as tags. Because a
+scanned endpoint is not a file, results point at the target URL unless you pass
+`--sarif-location`.
+
+## Rug-pull detection
+
+```console
+$ mcpprobe https://your-server.example/mcp --baseline .mcpprobe/baseline.json
+```
+
+The first run stores canonical SHA-256 hashes of every tool, prompt, resource and the
+server instructions. Later runs report anything added, removed or changed (a changed
+description after approval is the classic rug pull) and update the file; use
+`--no-write-baseline` to compare without updating.
+
+## Reports and evidence
+
+- `--json FILE`: the full report, including every request/response pair (timestamp,
+  method, status, a header subset, bodies truncated to 4 KB). `Authorization` values
+  and recognised secret patterns are redacted.
+- `--sarif FILE`: SARIF 2.1.0.
+- `-v`: descriptions and scan notes in the terminal; `-q`: no terminal output.
+
+Server-supplied text is shown with control characters made visible and is never
+interpreted as terminal markup.
+
+## Python API and LLM-judge hook
+
+```python
+import asyncio
+from mcpprobe.checks import JudgeVerdict, ScanOptions
+from mcpprobe.scanner import ScanConfig, run_scan
+
+
+def judge(text: str, task: str) -> JudgeVerdict | None:
+    return None  # plug in your own model here; mcpprobe makes no LLM calls
+
+
+report, evidence = asyncio.run(
+    run_scan(ScanConfig(target="https://your-server.example/mcp", options=ScanOptions(judge=judge)))
+)
+print(report.counts())
+```
+
+## Development
+
+```console
+$ pip install -e ".[dev]"
+$ ruff check . && ruff format --check . && mypy && pytest
+$ python -m tests.fake_server --preset vulnerable --port 8765   # deliberately vulnerable local server
+$ mcpprobe http://127.0.0.1:8765/mcp
+```
+
+Security issues: see [SECURITY.md](SECURITY.md). Licence: [MIT](LICENSE).

mcpprobe_scanner-0.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+mcpprobe/__init__.py,sha256=DY-sbjlh9JnxQG_v6UkZGtOApvi5LUU2t4oPbtEK_tc,821
+mcpprobe/action.py,sha256=6oag4JcDPvm-_H6Pp2OMY4M3WYeS4KSCwlsSLKtypYU,2366
+mcpprobe/authz.py,sha256=PCql53OFLQsN7oZxm2UtoAqTmT7LWRRw5nmx_50ePik,10595
+mcpprobe/catalogue.py,sha256=j0h-O-2FQq158P97bXf3akD0S3gzxt7P4AUJYMHbYss,4729
+mcpprobe/cli.py,sha256=UyA7KpuvKVCGV5hj-St_vU8sV267vI6RH_Xlp2NCkqs,10731
+mcpprobe/dnsutil.py,sha256=d9AWtU96SHE7QzphZk76L9r61LpI0MuxPYLHEijHK4Y,1958
+mcpprobe/governance.py,sha256=khs0t3jjSbwYzFYAjywnOzy_9m_qXy4ctuaFJy8UkdI,3391
+mcpprobe/models.py,sha256=U7dM-BRp0UZV6S0SErQH8UbdqYgWr917OV1kvlpvgqE,8662
+mcpprobe/policy.py,sha256=VWb6R3Udetp3AFk-BJqulRJREquyvtvP1VS8QhUOMdo,4865
+mcpprobe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcpprobe/redact.py,sha256=8VhTwssMnU2cKKL2dm2omLfjpxDWtX1GJTS8f_iWcTM,3775
+mcpprobe/scanner.py,sha256=XSxnyCO9Hr8JCyi5yeUSjZe4jEHw8ImFGgYuXUee1QU,8015
+mcpprobe/checks/__init__.py,sha256=dsf5exmjJlhyeonq4wnFm0gdsfzbzNYccIb8qbhhSqY,2855
+mcpprobe/checks/_util.py,sha256=5_8aLzoU3yfqWz6HcaHweb_j9KxuO0WgRDBiox39GIQ,3125
+mcpprobe/checks/active_stubs.py,sha256=zI-0sw2ncmg6B2tiia0laJOPcfzMFWfagY0G6wfPMfY,9129
+mcpprobe/checks/auth.py,sha256=q6Gu3wRfY3Gl-MyGe5tRCM7cseaqYg-t1kNLyFuw6Ww,21592
+mcpprobe/checks/base.py,sha256=MOTPdE4u8MVPGdzmXpn_rdjIsjaH65DmQeT1iQnwwHU,7884
+mcpprobe/checks/baseline.py,sha256=w-hwkN-OIczFephuXS7XSgjdTqOKkbTOEkHT16XWpK4,9847
+mcpprobe/checks/capability.py,sha256=ZS8bz5GOzFZ1JpzjpzAQ46pziixuwa97AkWOVdSY2oQ,5785
+mcpprobe/checks/metadata.py,sha256=dxoECGSxav8J-uEU0SX6R6HLVktTp0l1NtzT1ZMUik0,16554
+mcpprobe/checks/poisoning.py,sha256=NRA676paxs8IQujSOcPWWC9frn_7BxPdKV-OUjW1yKY,19054
+mcpprobe/checks/robustness.py,sha256=IggjqWHt21mEJk37OD2zr4w4bq7MRduaDVGEnkvMbJI,11865
+mcpprobe/checks/transport_conformance.py,sha256=7m8Lp54m9GOLfzGW7jmSOop4aNKxJAhtcygnUNdD_90,19189
+mcpprobe/report/__init__.py,sha256=n1Q29xF32h-8_VKiOHkvEl7uMf2VdKXyeDc9FLVO8u0,318
+mcpprobe/report/json_report.py,sha256=HGfax7PoH0YbbxDMnySWZFxehoMEnAlb93p8XyN8aFA,1362
+mcpprobe/report/sarif.py,sha256=NGkRiHPpNWBXBMaaAn2Xi_cOJ3hVa4z1ir3pIDcinmQ,13424
+mcpprobe/report/terminal.py,sha256=rK6kCvnX6gJxbrW0dMvtNpA5BbqdQ-kj0u9GHLwleF0,6596
+mcpprobe/transport/__init__.py,sha256=ZmUxTFl9Vm0MWy67Gb3BWM7LwL3ki1ZZ_8r54mK9f3U,863
+mcpprobe/transport/base.py,sha256=UFeFi2DfG1Yf5wh1gV6TTOIXWT7rLp-9wzH39Y_hTGI,5414
+mcpprobe/transport/evidence.py,sha256=rzeqnjc0a7olgDe-6S1QMD2v10Z1yKAcGsOF-VvJJUQ,4373
+mcpprobe/transport/fingerprint.py,sha256=B4A5dg9I-cRk7oWLAB8qt7MOlYUVnT70W5Uc-_HeQ-8,5609
+mcpprobe/transport/http.py,sha256=NHb-qfzAFF8A0B5HxTR7kz_pkceAjyJdOp5xAQbKZtE,13222
+mcpprobe/transport/ratelimit.py,sha256=g6mLxbVyXVVk0ndJ2jwJuC_RqfojbyHlABUTL7ys_9w,1578
+mcpprobe/transport/stdio.py,sha256=b_7cLDTidW5HVK_p7mT1fz0uYAdA7hh5ZlmFG65EBf4,7559
+mcpprobe_scanner-0.1.0.dist-info/METADATA,sha256=f7bpIvTuaFzBZ9VLpM-pS8WBMx8G5EZuCzCuDYn4CTI,9832
+mcpprobe_scanner-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+mcpprobe_scanner-0.1.0.dist-info/entry_points.txt,sha256=NEMxBH370sFz_Vw8812R7adD_DDQ3ZI7ixcuWZNQCHY,47
+mcpprobe_scanner-0.1.0.dist-info/licenses/LICENSE,sha256=Tzyy4bJyMSytgfl0I9_VubP5nGRQiGO4yYJKvyKUdpE,1078
+mcpprobe_scanner-0.1.0.dist-info/RECORD,,

mcpprobe_scanner-0.1.0.dist-info/WHEEL

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

mcpprobe_scanner-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcpprobe = mcpprobe.cli:main

mcpprobe_scanner-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mcpprobe contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.