browserid-mcp-auth 0.1.0__tar.gz

browserid_mcp_auth-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+/target
+broker-key.json
+browserid.db*
+.env
+
+# Test artifacts
+test-results/
+playwright-report/
+
+# macOS
+.DS_Store
+
+# Node
+node_modules
+
+# wallet-service
+wallet-service/wallet.db*
+wallet-service/.dev-kek
+wallet-service/.dev-session-secret
+__pycache__

browserid_mcp_auth-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.5
+Name: browserid-mcp-auth
+Version: 0.1.0
+Summary: Warrant-gated MCP tools over MCP's own OAuth 2.1: a BrowserID 7521 assertion-grant AS + fail-closed per-call revocation checks.
+Project-URL: Repository, https://github.com/vthunder/browserid-ng
+License-Expression: MPL-2.0
+Keywords: agent,browserid,fastmcp,mcp,oauth,rfc7521,warrant
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# browserid-mcp-auth (Python)
+
+Warrant-gated MCP tools over MCP's own OAuth 2.1 — the Python port of
+`@browserid-ng/mcp-auth`. **No API keys**: an agent redeems its human's
+short-lived, scoped, **revocable** BrowserID warrant for a bearer, and every
+tool call is attributable to "agent X on behalf of human Y". Revoke at
+`browserid.me/account` and the agent dies on its next call.
+
+An embedded authorization server (the RFC 7521 `jwt-bearer` assertion grant) +
+a resource-server guard that re-checks the warrant's revocation status
+**fail-closed on every call**. Verification is delegated to the broker's
+DNSSEC-rooted hosted verifier (`POST /verify-access`) and `POST /status/check`
+— no crypto in Python. Stdlib-only (no runtime deps).
+
+## Use
+
+```python
+from browserid_mcp_auth import McpAuth, McpAuthError
+
+auth = McpAuth(
+    resource="https://mcp.example.com",           # this server (OAuth resource + audience)
+    scopes_for_tool={"create_issue": ["issues:create"]},
+)
+
+# 1. Discovery (serve as JSON):
+#    GET /.well-known/oauth-protected-resource   -> auth.protected_resource_metadata()
+#    GET /.well-known/oauth-authorization-server  -> auth.authorization_server_metadata()
+
+# 2. Token endpoint (the embedded AS):
+#    POST /token  ->  auth.handle_token(request_body)   # {grant_type, assertion, scope?}
+
+# 3. Gate a tool call:
+ctx = auth.require_warrant(authorization_header, "create_issue")
+# ctx.grantor (human), ctx.grantee (agent), ctx.holder, ctx.issuer, ctx.scopes
+```
+
+On failure `handle_token` / `require_warrant` raise `McpAuthError` with
+`.oauth_error` and `.http_status`; render `err.to_token_error_response()` at the
+token endpoint and `auth.challenge()` in the `WWW-Authenticate` header on a 401.
+
+## FastMCP
+
+FastMCP servers speak MCP OAuth; mount the three surfaces above on the server's
+HTTP app (the token endpoint + the two discovery routes), and call
+`auth.require_warrant(request.headers.get("authorization"), tool_name)` at the
+top of each tool. The core is synchronous and dependency-free; call it directly
+or wrap in a thread from async handlers. `http_post` is injectable if you
+prefer `httpx`/`requests` over the stdlib `urllib` default.
+
+## API
+
+`McpAuth(resource, broker="https://browserid.me", scopes_for_tool=None,
+token_ttl_s=3600, status_cache_s=60, accepted_fallbacks=None, store=None,
+http_post=None)`; `handle_token(params)`, `authenticate(header)`,
+`require_warrant(header, tool_or_scopes)`, `protected_resource_metadata()`,
+`authorization_server_metadata()`, `challenge()`. MPL-2.0.

browserid_mcp_auth-0.1.0/README.md

@@ -0,0 +1,56 @@
+# browserid-mcp-auth (Python)
+
+Warrant-gated MCP tools over MCP's own OAuth 2.1 — the Python port of
+`@browserid-ng/mcp-auth`. **No API keys**: an agent redeems its human's
+short-lived, scoped, **revocable** BrowserID warrant for a bearer, and every
+tool call is attributable to "agent X on behalf of human Y". Revoke at
+`browserid.me/account` and the agent dies on its next call.
+
+An embedded authorization server (the RFC 7521 `jwt-bearer` assertion grant) +
+a resource-server guard that re-checks the warrant's revocation status
+**fail-closed on every call**. Verification is delegated to the broker's
+DNSSEC-rooted hosted verifier (`POST /verify-access`) and `POST /status/check`
+— no crypto in Python. Stdlib-only (no runtime deps).
+
+## Use
+
+```python
+from browserid_mcp_auth import McpAuth, McpAuthError
+
+auth = McpAuth(
+    resource="https://mcp.example.com",           # this server (OAuth resource + audience)
+    scopes_for_tool={"create_issue": ["issues:create"]},
+)
+
+# 1. Discovery (serve as JSON):
+#    GET /.well-known/oauth-protected-resource   -> auth.protected_resource_metadata()
+#    GET /.well-known/oauth-authorization-server  -> auth.authorization_server_metadata()
+
+# 2. Token endpoint (the embedded AS):
+#    POST /token  ->  auth.handle_token(request_body)   # {grant_type, assertion, scope?}
+
+# 3. Gate a tool call:
+ctx = auth.require_warrant(authorization_header, "create_issue")
+# ctx.grantor (human), ctx.grantee (agent), ctx.holder, ctx.issuer, ctx.scopes
+```
+
+On failure `handle_token` / `require_warrant` raise `McpAuthError` with
+`.oauth_error` and `.http_status`; render `err.to_token_error_response()` at the
+token endpoint and `auth.challenge()` in the `WWW-Authenticate` header on a 401.
+
+## FastMCP
+
+FastMCP servers speak MCP OAuth; mount the three surfaces above on the server's
+HTTP app (the token endpoint + the two discovery routes), and call
+`auth.require_warrant(request.headers.get("authorization"), tool_name)` at the
+top of each tool. The core is synchronous and dependency-free; call it directly
+or wrap in a thread from async handlers. `http_post` is injectable if you
+prefer `httpx`/`requests` over the stdlib `urllib` default.
+
+## API
+
+`McpAuth(resource, broker="https://browserid.me", scopes_for_tool=None,
+token_ttl_s=3600, status_cache_s=60, accepted_fallbacks=None, store=None,
+http_post=None)`; `handle_token(params)`, `authenticate(header)`,
+`require_warrant(header, tool_or_scopes)`, `protected_resource_metadata()`,
+`authorization_server_metadata()`, `challenge()`. MPL-2.0.

browserid_mcp_auth-0.1.0/browserid_mcp_auth/__init__.py

@@ -0,0 +1,296 @@
+"""browserid-mcp-auth — warrant-gated MCP tools over MCP's own OAuth 2.1.
+
+The Python port of ``@browserid-ng/mcp-auth``: an embedded authorization
+server that redeems a BrowserID warrant presentation for a short-lived scoped
+bearer via the RFC 7521 ``jwt-bearer`` assertion grant, plus a per-call guard
+that re-checks the warrant's revocation status **fail-closed** on every tool
+call. Hosts run their stock MCP OAuth client unmodified.
+
+No crypto in Python: verification is delegated to the broker's DNSSEC-rooted
+hosted verifier (``POST /verify-access``) and revocation to ``POST
+/status/check``. Framework-agnostic; wire into FastMCP / any server. See
+docs/plans/2026-08-02-mcp-distribution-design.md.
+"""
+from __future__ import annotations
+
+import json as _json
+import secrets
+import time
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Callable, Dict, List, Optional
+
+JWT_BEARER_GRANT = "urn:ietf:params:oauth:grant-type:jwt-bearer"
+
+__all__ = [
+    "JWT_BEARER_GRANT",
+    "McpAuth",
+    "McpAuthError",
+    "WarrantContext",
+    "MemoryStore",
+    "default_http_post",
+]
+
+
+class McpAuthError(Exception):
+    """Carries an OAuth error code + HTTP status for uniform rendering."""
+
+    def __init__(self, oauth_error: str, message: str, http_status: int = 400):
+        super().__init__(message)
+        self.oauth_error = oauth_error
+        self.http_status = http_status
+
+    def to_token_error_response(self) -> Dict[str, str]:
+        return {"error": self.oauth_error, "error_description": str(self)}
+
+
+@dataclass
+class WarrantContext:
+    grantor: Optional[str]
+    grantee: Optional[str]
+    holder: Optional[str]
+    issuer: Optional[str]
+    scopes: List[str]
+
+
+@dataclass
+class _Grant:
+    grantor: Optional[str]
+    grantee: Optional[str]
+    holder: Optional[str]
+    issuer: Optional[str]
+    scopes: List[str]
+    status_refs: List[dict]
+    exp: int
+    status_checked_at: int
+    status_ok: bool
+
+
+class MemoryStore:
+    """In-memory bearer store (single process). Swap for Redis/db in prod."""
+
+    def __init__(self) -> None:
+        self._grants: Dict[str, _Grant] = {}
+
+    def put(self, token: str, grant: _Grant) -> None:
+        self._grants[token] = grant
+
+    def get(self, token: str) -> Optional[_Grant]:
+        g = self._grants.get(token)
+        if g is None:
+            return None
+        if g.exp <= int(time.time()):
+            self._grants.pop(token, None)
+            return None
+        return g
+
+    def delete(self, token: str) -> None:
+        self._grants.pop(token, None)
+
+
+def default_http_post(url: str, body: dict, timeout: float = 10.0):
+    """POST JSON, return (status_code, parsed_json). Stdlib-only."""
+    data = _json.dumps(body).encode()
+    req = urllib.request.Request(
+        url, data=data, headers={"content-type": "application/json"}, method="POST"
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:  # noqa: S310
+            return resp.status, _json.loads(resp.read().decode() or "{}")
+    except urllib.error.HTTPError as e:  # type: ignore[attr-defined]
+        try:
+            return e.code, _json.loads(e.read().decode() or "{}")
+        except Exception:
+            return e.code, {}
+
+
+class McpAuth:
+    """The middleware. Construct once per MCP server.
+
+    :param resource: canonical URL of THIS server (OAuth resource + the
+        audience warrants must bind to).
+    :param broker: BrowserID broker origin (default https://browserid.me).
+    :param scopes_for_tool: ``{tool_name: [required scopes]}``.
+    :param token_ttl_s: bearer lifetime (default 3600).
+    :param status_cache_s: max seconds to trust a per-grant status result
+        before a fresh re-check (default 60).
+    :param accepted_fallbacks: fallback issuer domains (default [broker host]).
+    :param store: bearer store (default MemoryStore()).
+    :param http_post: injectable ``(url, body) -> (status, dict)`` (tests).
+    """
+
+    def __init__(
+        self,
+        resource: str,
+        broker: str = "https://browserid.me",
+        scopes_for_tool: Optional[Dict[str, List[str]]] = None,
+        token_ttl_s: int = 3600,
+        status_cache_s: int = 60,
+        accepted_fallbacks: Optional[List[str]] = None,
+        store: Optional[MemoryStore] = None,
+        http_post: Optional[Callable[[str, dict], tuple]] = None,
+    ) -> None:
+        if not resource:
+            raise ValueError("resource is required")
+        self.resource = resource.rstrip("/")
+        self.broker = broker.rstrip("/")
+        self.scopes_for_tool = scopes_for_tool or {}
+        self.token_ttl_s = token_ttl_s
+        self.status_cache_s = status_cache_s
+        from urllib.parse import urlparse
+
+        self.accepted_fallbacks = accepted_fallbacks or [urlparse(self.broker).netloc]
+        self.store = store or MemoryStore()
+        self._http_post = http_post or default_http_post
+        self._verify_url = f"{self.broker}/verify-access"
+        self._status_url = f"{self.broker}/status/check"
+
+    # -- discovery -----------------------------------------------------------
+
+    def _all_scopes(self) -> List[str]:
+        seen: List[str] = []
+        for scopes in self.scopes_for_tool.values():
+            for s in scopes:
+                if s not in seen:
+                    seen.append(s)
+        return seen
+
+    def protected_resource_metadata(self) -> dict:
+        return {
+            "resource": self.resource,
+            "authorization_servers": [self.resource],
+            "scopes_supported": self._all_scopes(),
+            "bearer_methods_supported": ["header"],
+        }
+
+    def authorization_server_metadata(self) -> dict:
+        return {
+            "issuer": self.resource,
+            "token_endpoint": f"{self.resource}/token",
+            "grant_types_supported": [JWT_BEARER_GRANT],
+            "token_endpoint_auth_methods_supported": ["none"],
+            "scopes_supported": self._all_scopes(),
+            "response_types_supported": [],
+        }
+
+    def challenge(self) -> str:
+        return f'Bearer resource_metadata="{self.resource}/.well-known/oauth-protected-resource"'
+
+    # -- token endpoint ------------------------------------------------------
+
+    def handle_token(self, params: dict) -> dict:
+        """Redeem a warrant presentation for a bearer. ``params`` is the token
+        request body ({grant_type, assertion, scope?}). Raises McpAuthError."""
+        if params.get("grant_type") != JWT_BEARER_GRANT:
+            raise McpAuthError("unsupported_grant_type", f"only {JWT_BEARER_GRANT} is supported")
+        presentation = params.get("assertion")
+        if not presentation or not isinstance(presentation, str):
+            raise McpAuthError("invalid_request", "missing 'assertion' (a browserid presentation)")
+
+        try:
+            code, verified = self._http_post(
+                self._verify_url,
+                {
+                    "presentation": presentation,
+                    "audience": self.resource,
+                    "accepted_fallbacks": self.accepted_fallbacks,
+                },
+            )
+        except Exception as e:  # fail-closed: an unreachable verifier is not approval
+            raise McpAuthError("temporarily_unavailable", f"verifier unreachable: {e}", 503)
+        if code < 200 or code >= 300:
+            raise McpAuthError("invalid_grant", f"verifier HTTP {code}")
+        if verified.get("status") != "okay":
+            raise McpAuthError("invalid_grant", verified.get("reason") or "presentation did not verify")
+
+        granted = verified.get("scopes") or []
+        requested = (params.get("scope") or "").split()
+        if requested:
+            scopes = [s for s in requested if s in granted]
+            if len(scopes) != len(requested):
+                raise McpAuthError("invalid_scope", "requested scope exceeds the warrant's grant")
+        else:
+            scopes = list(granted)
+
+        token = "bat_" + secrets.token_urlsafe(32)
+        now = int(time.time())
+        self.store.put(
+            token,
+            _Grant(
+                grantor=verified.get("email"),
+                grantee=verified.get("grantee") or verified.get("email"),
+                holder=verified.get("holder"),
+                issuer=verified.get("issuer"),
+                scopes=scopes,
+                status_refs=verified.get("status_refs") or [],
+                exp=now + self.token_ttl_s,
+                status_checked_at=now,
+                status_ok=True,
+            ),
+        )
+        return {
+            "access_token": token,
+            "token_type": "Bearer",
+            "expires_in": self.token_ttl_s,
+            "scope": " ".join(scopes),
+        }
+
+    # -- per-call validation -------------------------------------------------
+
+    def authenticate(self, authorization_header: Optional[str]) -> WarrantContext:
+        """Validate a Bearer header, re-check status fail-closed, return ctx."""
+        if not authorization_header:
+            raise McpAuthError("invalid_request", "missing Bearer token", 401)
+        parts = authorization_header.split(None, 1)
+        if len(parts) != 2 or parts[0].lower() != "bearer":
+            raise McpAuthError("invalid_request", "missing Bearer token", 401)
+        token = parts[1].strip()
+        grant = self.store.get(token)
+        if grant is None:
+            raise McpAuthError("invalid_token", "unknown or expired token", 401)
+        self._ensure_unrevoked(token, grant)
+        return WarrantContext(
+            grantor=grant.grantor,
+            grantee=grant.grantee,
+            holder=grant.holder,
+            issuer=grant.issuer,
+            scopes=list(grant.scopes),
+        )
+
+    def _ensure_unrevoked(self, token: str, grant: _Grant) -> None:
+        refs = grant.status_refs
+        if not refs:
+            return
+        now = int(time.time())
+        if grant.status_ok and now - grant.status_checked_at < self.status_cache_s:
+            return
+        try:
+            code, body = self._http_post(self._status_url, {"refs": refs})
+            if code < 200 or code >= 300:
+                raise RuntimeError(f"HTTP {code}")
+        except Exception as e:  # fail-closed
+            grant.status_ok = False
+            raise McpAuthError("invalid_token", f"status unavailable (fail-closed): {e}", 401)
+        if body.get("ok") is not True or body.get("revoked") is True:
+            grant.status_ok = False
+            self.store.delete(token)
+            raise McpAuthError("invalid_token", "warrant revoked", 401)
+        grant.status_ok = True
+        grant.status_checked_at = now
+
+    def require_warrant(self, authorization_header: Optional[str], tool_or_scopes) -> WarrantContext:
+        """authenticate + enforce a tool's required scopes (name or list)."""
+        ctx = self.authenticate(authorization_header)
+        required = (
+            list(tool_or_scopes)
+            if isinstance(tool_or_scopes, (list, tuple))
+            else self.scopes_for_tool.get(tool_or_scopes, [])
+        )
+        missing = [s for s in required if s not in ctx.scopes]
+        if missing:
+            raise McpAuthError(
+                "insufficient_scope",
+                f"this tool needs scope(s) {missing} not in the warrant",
+                403,
+            )
+        return ctx

browserid_mcp_auth-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "browserid-mcp-auth"
+version = "0.1.0"
+description = "Warrant-gated MCP tools over MCP's own OAuth 2.1: a BrowserID 7521 assertion-grant AS + fail-closed per-call revocation checks."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MPL-2.0"
+keywords = ["browserid", "mcp", "oauth", "agent", "warrant", "fastmcp", "rfc7521"]
+
+[project.urls]
+Repository = "https://github.com/vthunder/browserid-ng"
+
+[tool.hatch.build.targets.wheel]
+packages = ["browserid_mcp_auth"]

browserid_mcp_auth-0.1.0/tests/test_mcp_auth.py

@@ -0,0 +1,181 @@
+"""Unit tests for browserid-mcp-auth (stdlib unittest — no pytest needed)."""
+import sys
+import time
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from browserid_mcp_auth import (  # noqa: E402
+    JWT_BEARER_GRANT,
+    McpAuth,
+    McpAuthError,
+)
+
+RESOURCE = "https://mcp.example.com"
+
+OK_VERIFY = {
+    "status": "okay",
+    "email": "dan@sandmill.org",
+    "grantee": "dan+claude@sandmill.org",
+    "holder": "agents.abc123",
+    "issuer": "sandmill.org",
+    "scopes": ["repo:read", "issues:create"],
+    "status_refs": [{"uri": "https://browserid.me/.well-known/browserid-status", "idx": 7}],
+}
+
+
+class FakeBroker:
+    """Configurable (status_code, json) responses for /verify-access + /status/check."""
+
+    def __init__(self, verify=None, status=None):
+        self.verify = verify
+        self.status = status
+        self.calls = {"verify": 0, "status": 0}
+
+    def post(self, url, body):
+        if url.endswith("/verify-access"):
+            self.calls["verify"] += 1
+            if self.verify == "throw":
+                raise ConnectionError("refused")
+            v = self.verify if self.verify is not None else {"status": "failure"}
+            return v.get("__status", 200), v
+        if url.endswith("/status/check"):
+            self.calls["status"] += 1
+            if self.status == "throw":
+                raise ConnectionError("refused")
+            s = self.status if self.status is not None else {"ok": True, "revoked": False}
+            return s.get("__status", 200), s
+        raise AssertionError("unexpected url " + url)
+
+
+def make(verify=OK_VERIFY, status=None, **kw):
+    broker = FakeBroker(verify=verify, status=status)
+    mcp = McpAuth(resource=RESOURCE, broker="https://browserid.me", http_post=broker.post,
+                  scopes_for_tool={"create_issue": ["issues:create"], "admin": ["repo:admin"]},
+                  status_cache_s=kw.pop("status_cache_s", 0), **kw)
+    return mcp, broker
+
+
+TOKEN_REQ = {"grant_type": JWT_BEARER_GRANT, "assertion": "AC~AS~WR~CC"}
+
+
+class TokenEndpoint(unittest.TestCase):
+    def test_rejects_bad_grant(self):
+        mcp, _ = make()
+        with self.assertRaises(McpAuthError) as c:
+            mcp.handle_token({"grant_type": "authorization_code", "assertion": "x"})
+        self.assertEqual(c.exception.oauth_error, "unsupported_grant_type")
+
+    def test_rejects_missing_assertion(self):
+        mcp, _ = make()
+        with self.assertRaises(McpAuthError) as c:
+            mcp.handle_token({"grant_type": JWT_BEARER_GRANT})
+        self.assertEqual(c.exception.oauth_error, "invalid_request")
+
+    def test_mints_bearer(self):
+        mcp, _ = make()
+        res = mcp.handle_token(TOKEN_REQ)
+        self.assertEqual(res["token_type"], "Bearer")
+        self.assertTrue(res["access_token"].startswith("bat_"))
+        self.assertEqual(res["scope"], "repo:read issues:create")
+        ctx = mcp.authenticate("Bearer " + res["access_token"])
+        self.assertEqual(ctx.grantor, "dan@sandmill.org")
+        self.assertEqual(ctx.grantee, "dan+claude@sandmill.org")
+
+    def test_bad_presentation_rejected(self):
+        mcp, _ = make(verify={"status": "failure", "reason": "expired"})
+        with self.assertRaises(McpAuthError) as c:
+            mcp.handle_token(TOKEN_REQ)
+        self.assertEqual(c.exception.oauth_error, "invalid_grant")
+
+    def test_unreachable_verifier_fails_closed(self):
+        mcp, _ = make(verify="throw")
+        with self.assertRaises(McpAuthError) as c:
+            mcp.handle_token(TOKEN_REQ)
+        self.assertEqual(c.exception.http_status, 503)
+
+    def test_scope_narrow_not_widen(self):
+        mcp, _ = make()
+        self.assertEqual(mcp.handle_token({**TOKEN_REQ, "scope": "repo:read"})["scope"], "repo:read")
+        with self.assertRaises(McpAuthError) as c:
+            mcp.handle_token({**TOKEN_REQ, "scope": "repo:read repo:admin"})
+        self.assertEqual(c.exception.oauth_error, "invalid_scope")
+
+
+class PerCall(unittest.TestCase):
+    def test_unknown_token(self):
+        mcp, _ = make()
+        with self.assertRaises(McpAuthError) as c:
+            mcp.authenticate("Bearer nope")
+        self.assertEqual(c.exception.http_status, 401)
+
+    def test_revoke_kills_token(self):
+        broker = FakeBroker(verify=OK_VERIFY, status={"ok": True, "revoked": False})
+        mcp = McpAuth(resource=RESOURCE, http_post=broker.post, status_cache_s=0)
+        tok = mcp.handle_token(TOKEN_REQ)["access_token"]
+        mcp.authenticate("Bearer " + tok)  # fine
+        broker.status = {"ok": False, "revoked": True}
+        with self.assertRaises(McpAuthError) as c:
+            mcp.authenticate("Bearer " + tok)
+        self.assertIn("revoked", str(c.exception))
+
+    def test_status_unreachable_fails_closed(self):
+        mcp, _ = make(status="throw")
+        tok = mcp.handle_token(TOKEN_REQ)["access_token"]
+        with self.assertRaises(McpAuthError) as c:
+            mcp.authenticate("Bearer " + tok)
+        self.assertIn("fail-closed", str(c.exception))
+
+    def test_no_refs_no_recheck(self):
+        v = {**OK_VERIFY, "status_refs": []}
+        mcp, broker = make(verify=v)
+        tok = mcp.handle_token(TOKEN_REQ)["access_token"]
+        mcp.authenticate("Bearer " + tok)
+        self.assertEqual(broker.calls["status"], 0)
+
+    def test_status_cache(self):
+        mcp, broker = make(status={"ok": True, "revoked": False}, status_cache_s=300)
+        tok = mcp.handle_token(TOKEN_REQ)["access_token"]
+        before = broker.calls["status"]
+        mcp.authenticate("Bearer " + tok)
+        mcp.authenticate("Bearer " + tok)
+        self.assertEqual(broker.calls["status"], before)  # cached from verify
+
+
+class Scopes(unittest.TestCase):
+    def test_require_warrant(self):
+        mcp, _ = make()
+        tok = mcp.handle_token(TOKEN_REQ)["access_token"]
+        hdr = "Bearer " + tok
+        ctx = mcp.require_warrant(hdr, "create_issue")  # issues:create granted
+        self.assertEqual(ctx.grantee, "dan+claude@sandmill.org")
+        with self.assertRaises(McpAuthError) as c:
+            mcp.require_warrant(hdr, "admin")  # repo:admin not granted
+        self.assertEqual(c.exception.http_status, 403)
+        mcp.require_warrant(hdr, ["repo:read"])  # explicit list
+
+
+class Metadata(unittest.TestCase):
+    def test_discovery(self):
+        mcp, _ = make()
+        prm = mcp.protected_resource_metadata()
+        self.assertEqual(prm["resource"], RESOURCE)
+        asm = mcp.authorization_server_metadata()
+        self.assertEqual(asm["token_endpoint"], RESOURCE + "/token")
+        self.assertEqual(asm["grant_types_supported"], [JWT_BEARER_GRANT])
+        self.assertIn("resource_metadata=", mcp.challenge())
+
+
+class Expiry(unittest.TestCase):
+    def test_expired_bearer(self):
+        mcp, _ = make(token_ttl_s=-1)
+        tok = mcp.handle_token(TOKEN_REQ)["access_token"]
+        time.sleep(0.01)
+        with self.assertRaises(McpAuthError) as c:
+            mcp.authenticate("Bearer " + tok)
+        self.assertEqual(c.exception.http_status, 401)
+
+
+if __name__ == "__main__":
+    unittest.main()

browserid_mcp_auth-0.1.0/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 3
+requires-python = ">=3.9"
+
+[[package]]
+name = "browserid-mcp-auth"
+version = "0.1.0"
+source = { editable = "." }