mirror of
https://github.com/andrewyng/openworker.git
synced 2026-11-17 15:54:08 +00:00
Supabase's hosted MCP server ignores the `token_endpoint_auth_method: "none"` we send to its dynamic client registration endpoint: it answers 201 with a `client_secret` and omits the method entirely. The MCP SDK then reads the auth method off the client info and, for an absent/"none" method, adds no secret to the token request (`mcp/client/auth/oauth2.py`, `prepare_token_auth`), so every exchange fails with `422 Required parameter: client_secret` and one-click Connect can never finish. Supabase's authorization-server metadata advertises only `client_secret_basic`/`client_secret_post`, never `none`, so the registration really is confidential whatever the client asked for. Record the method the issued secret implies, and correct the object the SDK keeps live in its context rather than only the copy we store: the SDK assigns the registration to `context.client_info` immediately before handing us that same instance, and re-reads the method from the live copy at token-exchange time. Normalizing just the stored copy leaves the connect that had just registered still sending no secret -- the first version of this fix passed its reload test and still failed a real browser sign-in with the same 422. Verified against the live server: - token exchange with an invalid code: 422 -> 404 "Invalid or expired OAuth authorization", i.e. the client now authenticates and only the dummy code is rejected - full browser sign-in: session authorized, 29 tools listed, tokens stored Tests in tests/test_mcp_oauth.py cover the stored record, the SDK-built token request, and the live-object ordering. Reverting the fix fails all three.
375 lines
15 KiB
Python
375 lines
15 KiB
Python
"""MCP OAuth (browser sign-in for remote servers, mcp/oauth.py): config parsing, token
|
|
persistence in the SecretStore, callback plumbing, status surfacing, and the loopback
|
|
route. No live OAuth server — the SDK's flow itself is upstream-tested; these guard OUR
|
|
integration points."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import json
|
|
|
|
import pytest
|
|
from fastapi.testclient import TestClient
|
|
from mcp.shared.auth import OAuthClientInformationFull, OAuthToken
|
|
|
|
from coworker.mcp import oauth as mcp_oauth
|
|
from coworker.mcp.config import load_mcp_servers
|
|
from coworker.secrets import SecretStore
|
|
from coworker.server.app import create_app
|
|
from coworker.server.manager import SessionManager
|
|
|
|
GRANOLA = {"type": "http", "url": "https://mcp.granola.ai/mcp", "auth": "oauth"}
|
|
|
|
|
|
def _state(tmp_path, monkeypatch, servers=None):
|
|
monkeypatch.setenv("COWORKER_STATE_DIR", str(tmp_path / "state"))
|
|
path = tmp_path / "state" / "mcp.json"
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(json.dumps({"mcpServers": servers or {}}), encoding="utf-8")
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _no_pending():
|
|
mcp_oauth._pending = None
|
|
mcp_oauth._expected_state = None
|
|
yield
|
|
mcp_oauth._pending = None
|
|
mcp_oauth._expected_state = None
|
|
|
|
|
|
# -- config --------------------------------------------------------------------
|
|
|
|
|
|
def test_config_parses_auth_field(tmp_path, monkeypatch):
|
|
_state(
|
|
tmp_path, monkeypatch, {"granola": GRANOLA, "plain": {"url": "https://x/mcp"}}
|
|
)
|
|
servers = {s.name: s for s in load_mcp_servers()}
|
|
assert servers["granola"].auth == "oauth"
|
|
assert servers["granola"].transport == "http"
|
|
assert servers["plain"].auth is None
|
|
|
|
|
|
# -- token storage ---------------------------------------------------------------
|
|
|
|
|
|
def test_token_storage_roundtrip(tmp_path, monkeypatch):
|
|
_state(tmp_path, monkeypatch)
|
|
secrets = SecretStore()
|
|
storage = mcp_oauth.SecretStoreTokenStorage("granola", secrets)
|
|
|
|
async def run():
|
|
assert await storage.get_tokens() is None
|
|
await storage.set_tokens(
|
|
OAuthToken.model_validate(
|
|
{"access_token": "at", "token_type": "Bearer", "refresh_token": "rt"}
|
|
)
|
|
)
|
|
await storage.set_client_info(
|
|
OAuthClientInformationFull.model_validate(
|
|
{
|
|
"client_id": "dcr-123",
|
|
"redirect_uris": ["http://127.0.0.1:8765/mcp/oauth/callback"],
|
|
}
|
|
)
|
|
)
|
|
tokens = await storage.get_tokens()
|
|
info = await storage.get_client_info()
|
|
return tokens, info
|
|
|
|
tokens, info = asyncio.run(run())
|
|
assert tokens.access_token == "at" and tokens.refresh_token == "rt"
|
|
assert info.client_id == "dcr-123" # DCR registration survives restarts
|
|
assert mcp_oauth.has_tokens("granola", secrets)
|
|
assert mcp_oauth.sign_out("granola", secrets)
|
|
assert not mcp_oauth.has_tokens("granola", secrets)
|
|
|
|
|
|
def test_dcr_secret_without_method_is_recorded_as_client_secret_post(
|
|
tmp_path, monkeypatch
|
|
):
|
|
"""Supabase's hosted MCP registers a CONFIDENTIAL client: DCR answers 201 with a
|
|
client_secret while ignoring the `token_endpoint_auth_method: "none"` we asked for and
|
|
omitting the field (verified against api.supabase.com/platform/oauth/apps/register).
|
|
The SDK takes the method off the stored registration and sends no secret when it is
|
|
absent/"none", so the token exchange 422s "Required parameter: client_secret" and
|
|
one-click Connect can never finish. Storage records what the issued secret implies."""
|
|
_state(tmp_path, monkeypatch)
|
|
storage = mcp_oauth.SecretStoreTokenStorage("supabase", SecretStore())
|
|
redirect = {"redirect_uris": ["http://127.0.0.1:8765/mcp/oauth/callback"]}
|
|
|
|
async def roundtrip(registration):
|
|
await storage.set_client_info(
|
|
OAuthClientInformationFull.model_validate(registration)
|
|
)
|
|
return await storage.get_client_info()
|
|
|
|
# Supabase: secret issued, method absent -> inferred as confidential.
|
|
info = asyncio.run(roundtrip({"client_id": "dcr-1", "client_secret": "s3cret", **redirect}))
|
|
assert info.client_secret == "s3cret"
|
|
assert info.token_endpoint_auth_method == "client_secret_post"
|
|
|
|
# A genuinely public DCR (no secret) stays public: nothing is invented.
|
|
info = asyncio.run(roundtrip({"client_id": "dcr-2", **redirect}))
|
|
assert info.client_secret is None
|
|
assert info.token_endpoint_auth_method is None
|
|
|
|
# A method the server names always wins, secret or not.
|
|
info = asyncio.run(
|
|
roundtrip({"client_id": "dcr-3", "client_secret": "s3cret",
|
|
"token_endpoint_auth_method": "client_secret_basic", **redirect})
|
|
)
|
|
assert info.token_endpoint_auth_method == "client_secret_basic"
|
|
|
|
|
|
def test_confidential_registration_puts_secret_in_the_token_request(
|
|
tmp_path, monkeypatch
|
|
):
|
|
"""The point of recording the method: the SDK's own token request now carries the
|
|
secret. Built with the SDK's real `prepare_token_auth`, through the provider
|
|
`build_auth` hands to streamablehttp_client — the request that used to 422."""
|
|
_state(tmp_path, monkeypatch)
|
|
secrets = SecretStore()
|
|
|
|
async def run():
|
|
auth = mcp_oauth.build_auth("supabase", "https://mcp.supabase.com/mcp", secrets)
|
|
await auth.context.storage.set_client_info(
|
|
OAuthClientInformationFull.model_validate(
|
|
{
|
|
"client_id": "dcr-1",
|
|
"client_secret": "s3cret",
|
|
"redirect_uris": ["http://127.0.0.1:8765/mcp/oauth/callback"],
|
|
}
|
|
)
|
|
)
|
|
auth.context.client_info = await auth.context.storage.get_client_info()
|
|
data, headers = auth.context.prepare_token_auth(
|
|
{"grant_type": "authorization_code", "code": "c0de", "client_id": "dcr-1"}
|
|
)
|
|
return data, headers
|
|
|
|
data, _headers = asyncio.run(run())
|
|
assert data["client_secret"] == "s3cret"
|
|
|
|
|
|
def test_registration_is_corrected_on_the_object_the_sdk_keeps_live(tmp_path, monkeypatch):
|
|
"""The SDK keeps the registered object ITSELF live (`context.client_info =
|
|
client_information`) and calls storage with that same instance, then reads the method off
|
|
that live copy when building the token request. So the correction has to land on the
|
|
object, not only in the store: a version that normalized just the stored copy satisfied
|
|
the reload test above while a real one-click Connect still 422d "Required parameter:
|
|
client_secret" right after a successful browser sign-in (live run 2026-09-27)."""
|
|
_state(tmp_path, monkeypatch)
|
|
secrets = SecretStore()
|
|
|
|
async def run():
|
|
auth = mcp_oauth.build_auth("supabase", "https://mcp.supabase.com/mcp", secrets)
|
|
registration = OAuthClientInformationFull.model_validate(
|
|
{
|
|
"client_id": "dcr-1",
|
|
"client_secret": "s3cret",
|
|
"redirect_uris": ["http://127.0.0.1:8765/mcp/oauth/callback"],
|
|
}
|
|
)
|
|
# Exactly the SDK's Step 4 ordering: assign it live, then hand us the same object.
|
|
auth.context.client_info = registration
|
|
await auth.context.storage.set_client_info(registration)
|
|
data, _headers = auth.context.prepare_token_auth(
|
|
{"grant_type": "authorization_code", "code": "c0de", "client_id": "dcr-1"}
|
|
)
|
|
return registration, data
|
|
|
|
registration, data = asyncio.run(run())
|
|
assert registration.token_endpoint_auth_method == "client_secret_post"
|
|
assert data["client_secret"] == "s3cret"
|
|
|
|
|
|
# -- callback plumbing -----------------------------------------------------------
|
|
|
|
|
|
def test_deliver_without_waiter_is_rejected():
|
|
assert mcp_oauth.deliver_callback("code", "state") is False
|
|
|
|
|
|
def test_wait_then_deliver_resolves():
|
|
async def run():
|
|
task = asyncio.create_task(mcp_oauth._wait_for_callback())
|
|
await asyncio.sleep(0) # let the waiter install its future
|
|
assert mcp_oauth.deliver_callback("c0de", "st4te") is True
|
|
return await task
|
|
|
|
assert asyncio.run(run()) == ("c0de", "st4te")
|
|
|
|
|
|
def test_state_from_url():
|
|
url = "https://idp.example/authorize?client_id=x&state=abc123&scope=y"
|
|
assert mcp_oauth._state_from_url(url) == "abc123"
|
|
assert mcp_oauth._state_from_url("https://idp.example/authorize?client_id=x") is None
|
|
|
|
|
|
def test_deliver_rejects_mismatched_state_without_consuming_flow():
|
|
# A stray/forged loopback hit with the wrong state must NOT resolve or consume the
|
|
# pending future — the genuine redirect (correct state) still gets through.
|
|
async def run():
|
|
task = asyncio.create_task(mcp_oauth._wait_for_callback())
|
|
await asyncio.sleep(0)
|
|
mcp_oauth._expected_state = "good-state" # captured from the authorize URL
|
|
# Wrong state and missing state are both ignored, flow stays pending.
|
|
assert mcp_oauth.deliver_callback("evil", "bad-state") is False
|
|
assert mcp_oauth.deliver_callback("evil", None) is False
|
|
assert not task.done()
|
|
# The real browser redirect carries the matching state and resolves the flow.
|
|
assert mcp_oauth.deliver_callback("c0de", "good-state") is True
|
|
return await task
|
|
|
|
assert asyncio.run(run()) == ("c0de", "good-state")
|
|
|
|
|
|
# -- status surfacing over REST ---------------------------------------------------
|
|
|
|
|
|
def test_list_mcp_oauth_statuses(tmp_path, monkeypatch):
|
|
_state(tmp_path, monkeypatch, {"granola": GRANOLA})
|
|
manager = SessionManager(data_dir=tmp_path / "data")
|
|
client = TestClient(create_app(manager))
|
|
|
|
row = client.get("/v1/mcp").json()["servers"][0]
|
|
assert row["auth"] == "oauth" and row["status"] == "needs_auth"
|
|
|
|
manager._mcp_authorizing.add("granola")
|
|
assert client.get("/v1/mcp").json()["servers"][0]["status"] == "authorizing"
|
|
manager._mcp_authorizing.discard("granola")
|
|
|
|
manager._mcp_errors["granola"] = "sign-in timed out"
|
|
row = client.get("/v1/mcp").json()["servers"][0]
|
|
assert row["last_error"] == "sign-in timed out"
|
|
|
|
manager.secrets.put("mcp-oauth:granola", {"tokens": {"access_token": "at"}})
|
|
assert client.get("/v1/mcp").json()["servers"][0]["status"] == "configured"
|
|
|
|
assert client.post("/v1/mcp/granola/signout").json()["ok"] is True
|
|
assert not mcp_oauth.has_tokens("granola", manager.secrets)
|
|
assert client.get("/v1/mcp").json()["servers"][0]["status"] == "needs_auth"
|
|
|
|
|
|
def test_connect_endpoint_starts_background_flow(tmp_path, monkeypatch):
|
|
_state(tmp_path, monkeypatch, {"granola": GRANOLA})
|
|
manager = SessionManager(data_dir=tmp_path / "data")
|
|
|
|
seen = {}
|
|
|
|
async def fake_connect(name):
|
|
seen["name"] = name
|
|
return {"ok": True}
|
|
|
|
monkeypatch.setattr(manager, "connect_mcp", fake_connect)
|
|
client = TestClient(create_app(manager))
|
|
assert client.post("/v1/mcp/granola/connect").json() == {
|
|
"ok": True,
|
|
"started": True,
|
|
}
|
|
assert seen["name"] == "granola"
|
|
|
|
|
|
# -- loopback route ----------------------------------------------------------------
|
|
|
|
|
|
def test_callback_route(tmp_path, monkeypatch):
|
|
_state(tmp_path, monkeypatch)
|
|
manager = SessionManager(data_dir=tmp_path / "data")
|
|
client = TestClient(create_app(manager))
|
|
|
|
# Provider error → failure page.
|
|
r = client.get("/mcp/oauth/callback", params={"error": "access_denied"})
|
|
assert r.status_code == 400 and "failed" in r.text.lower()
|
|
|
|
# No flow waiting → stale-tab page.
|
|
r = client.get("/mcp/oauth/callback", params={"code": "x"})
|
|
assert r.status_code == 400 and "waiting" in r.text.lower()
|
|
|
|
# A waiting flow gets the code and the browser sees the success page.
|
|
loop = asyncio.new_event_loop()
|
|
try:
|
|
future = loop.create_future()
|
|
mcp_oauth._pending = future
|
|
r = client.get("/mcp/oauth/callback", params={"code": "c1", "state": "s1"})
|
|
assert r.status_code == 200 and "close this tab" in r.text.lower()
|
|
assert future.result() == ("c1", "s1")
|
|
finally:
|
|
loop.close()
|
|
|
|
|
|
# -- stale-token countermeasures (owner-hit 2026-08-21, DLAI Redshift) ----------
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_storage_reports_remaining_lifetime_and_blanks_stale_access(tmp_path, monkeypatch):
|
|
"""The SDK never computes expiry for tokens loaded from storage and treats a
|
|
None expiry as valid-forever — so storage must (a) report the REMAINING
|
|
lifetime from the issued_at it persists and (b) blank the access token once
|
|
stale, which makes the SDK run the refresh grant before the request."""
|
|
from mcp.shared.auth import OAuthToken
|
|
|
|
from coworker.secrets import SecretStore
|
|
|
|
secrets = SecretStore(tmp_path / "s.json")
|
|
storage = mcp_oauth.SecretStoreTokenStorage("dlai", secrets)
|
|
|
|
now = 1_000_000.0
|
|
monkeypatch.setattr(mcp_oauth.time, "time", lambda: now)
|
|
await storage.set_tokens(
|
|
OAuthToken(access_token="A", expires_in=3600, refresh_token="R")
|
|
)
|
|
|
|
# Fresh: full remaining lifetime, access token intact.
|
|
tok = await storage.get_tokens()
|
|
assert tok.access_token == "A" and tok.expires_in == 3600
|
|
|
|
# Half-spent: remaining shrinks with the clock.
|
|
monkeypatch.setattr(mcp_oauth.time, "time", lambda: now + 1800)
|
|
tok = await storage.get_tokens()
|
|
assert tok.access_token == "A" and tok.expires_in == 1800
|
|
|
|
# Past expiry: access token blanked (refresh token kept) → SDK refreshes first.
|
|
monkeypatch.setattr(mcp_oauth.time, "time", lambda: now + 3700)
|
|
tok = await storage.get_tokens()
|
|
assert tok.access_token == "" and tok.refresh_token == "R"
|
|
assert tok.expires_in <= 0
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_storage_treats_unknown_token_age_as_stale(tmp_path):
|
|
"""Tokens persisted before issued_at existed have unknown age — assume stale
|
|
(blank access, keep refresh) rather than sending an hour-old bearer."""
|
|
from coworker.secrets import SecretStore
|
|
|
|
secrets = SecretStore(tmp_path / "s.json")
|
|
secrets.put(
|
|
"mcp-oauth:dlai",
|
|
{"tokens": {"access_token": "A", "expires_in": 3600, "refresh_token": "R"}},
|
|
)
|
|
storage = mcp_oauth.SecretStoreTokenStorage("dlai", secrets)
|
|
tok = await storage.get_tokens()
|
|
assert tok.access_token == "" and tok.refresh_token == "R"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_provider_seeds_and_persists_oauth_metadata(tmp_path):
|
|
"""The refresh grant runs BEFORE the SDK's discovery, so the provider must
|
|
seed persisted authorization-server metadata at load — otherwise refresh
|
|
POSTs to the default <origin>/token (404 on data.dlai.link)."""
|
|
from coworker.secrets import SecretStore
|
|
|
|
secrets = SecretStore(tmp_path / "s.json")
|
|
md = {
|
|
"issuer": "https://data.example",
|
|
"authorization_endpoint": "https://data.example/api/auth/authorize",
|
|
"token_endpoint": "https://data.example/api/auth/token",
|
|
}
|
|
secrets.put("mcp-oauth:dlai", {"oauth_metadata": md})
|
|
auth = mcp_oauth.build_auth(
|
|
"dlai", "https://data.example/api/mcp", secrets, interactive=False
|
|
)
|
|
await auth._initialize()
|
|
assert str(auth.context.oauth_metadata.token_endpoint) == md["token_endpoint"]
|