Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

190 KB
Raw Blame
from __future__ import annotations

import asyncio
import html
import json
import re
import threading
import time
from datetime import timedelta
from types import SimpleNamespace
from urllib.parse import parse_qs, unquote_plus, urlencode, urlparse
from uuid import uuid4

import httpx
import pytest
from fastapi import HTTPException
from sqlalchemy import create_engine, event
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Query, sessionmaker
from starlette.requests import Request

from tests.shared.async_waits import DB_PROGRESS_TIMEOUT
from xagent.core.tools.adapters.vibe.connector_runtime import ConnectorRef
from xagent.core.tools.adapters.vibe.mcp_adapter import (
    MCPFailurePhase,
    MCPLoadResult,
    MCPServerLoadFailure,
)
from xagent.core.utils.encryption import decrypt_value, encrypt_value
from xagent.web.api import mcp as mcp_api
from xagent.web.api.mcp import (
    MCPOAuthConnectRequest,
    MCPOAuthDiscoverRequest,
    MCPOAuthStatusResponse,
    MCPServerUpdate,
    connect_mcp_oauth,
    connect_mcp_oauth_app,
    delete_mcp_oauth_grant,
    delete_mcp_server,
    discover_mcp_oauth,
    get_mcp_oauth_status,
    get_mcp_server_tools,
    list_mcp_apps,
    mcp_oauth_callback,
    update_mcp_server,
)
from xagent.web.builtin_mcp_registry import get_builtin_public_mcp_app
from xagent.web.models import MCPOAuthClient, MCPOAuthFlowState, MCPOAuthGrant
from xagent.web.models.database import Base
from xagent.web.models.mcp import MCPServer, UserMCPServer
from xagent.web.models.mcp_oauth import mcp_oauth_client_registration_lookup_hash
from xagent.web.models.public_mcp import PublicMCPApp
from xagent.web.models.user import User
from xagent.web.models.user_oauth import UserOAuth
from xagent.web.services import connector_team_scope
from xagent.web.services import mcp_oauth as mcp_oauth_service
from xagent.web.services.mcp_oauth import (
    MCP_OAUTH_PERSISTED_VALUE_MAX_LENGTH,
    MCP_OAUTH_RESOURCE_OWNER_KEY_MAX_LENGTH,
    MCP_OAUTH_SCOPE_MAX_LENGTH,
    MCP_OAUTH_TOKEN_ENDPOINT_AUTH_METHOD_MAX_LENGTH,
    MCP_OAUTH_TOKEN_TYPE_MAX_LENGTH,
)


@pytest.fixture()
def db_session(tmp_path):
    db_path = tmp_path / "mcp-oauth.db"
    engine = create_engine(
        f"sqlite:///{db_path}", connect_args={"check_same_thread": False}
    )
    with engine.connect() as connection:
        assert connection.exec_driver_sql("PRAGMA journal_mode=WAL").scalar() == "wal"
    Base.metadata.create_all(engine)
    SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False)
    db = SessionLocal()

    user = User(username="alice", password_hash="x", is_admin=False)
    other_user = User(username="bob", password_hash="x", is_admin=False)
    db.add_all([user, other_user])
    db.commit()
    db.refresh(user)
    db.refresh(other_user)

    yield db, user, other_user
    db.close()
    engine.dispose()


def _request(
    path: str,
    headers: list[tuple[bytes, bytes]] | None = None,
    *,
    bind_oauth_state_cookie: bool = True,
) -> Request:
    parsed = urlparse(path)
    request_headers = list(headers or [])
    query = parse_qs(parsed.query)
    state = query.get("state", [None])[0]
    if bind_oauth_state_cookie and parsed.path == "/api/mcp/oauth/callback" and state:
        request_headers.append(
            (
                b"cookie",
                (
                    f"{mcp_api.MCP_OAUTH_STATE_COOKIE}="
                    f"{mcp_api._mcp_oauth_state_cookie_value(state)}"
                ).encode(),
            )
        )
    return Request(
        {
            "type": "http",
            "method": "GET",
            "path": parsed.path,
            "query_string": parsed.query.encode(),
            "headers": request_headers,
        }
    )


def _redirect_query(response):
    return parse_qs(urlparse(response.headers["location"]).query)


def _discovery() -> SimpleNamespace:
    return SimpleNamespace(
        resource="https://mcp.example.com/mcp",
        scopes=("records.read",),
        protected_resource=SimpleNamespace(
            authorization_servers=("https://auth.example.com",),
        ),
        authorization_server=SimpleNamespace(
            issuer="https://auth.example.com",
            authorization_endpoint="https://auth.example.com/authorize",
            token_endpoint="https://auth.example.com/token",
            registration_endpoint="https://auth.example.com/register",
            client_id_metadata_document_supported=True,
            raw={"issuer": "https://auth.example.com"},
        ),
    )


def _add_mcp_oauth_server(
    db,
    user: User,
    *,
    name: str = "records",
    scope: str = "records.read",
    transport: str = "streamable_http",
    client_id: str = "client-123",
    client_secret: str | None = "client-secret",
    redirect_uri: str | None = "https://xagent.example.com/api/mcp/oauth/callback",
    token_endpoint_auth_method: str = "client_secret_post",
) -> MCPServer:
    server = MCPServer.from_config(
        {
            "name": name,
            "managed": "external",
            "transport": transport,
            "url": "https://mcp.example.com/mcp",
            "auth": {
                "type": "mcp_oauth",
                "resource": "https://mcp.example.com/mcp",
                "issuer": "https://auth.example.com",
                "scope": scope,
                "client_id": client_id,
                "client_secret": client_secret,
                "redirect_uri": redirect_uri,
                "token_endpoint_auth_method": token_endpoint_auth_method,
            },
        }
    )
    db.add(server)
    db.commit()
    db.refresh(server)
    db.add(
        UserMCPServer(
            user_id=user.id,
            mcpserver_id=server.id,
            is_owner=True,
            is_active=True,
        )
    )
    db.commit()
    return server


def _add_oauth_client(
    db,
    server: MCPServer,
    *,
    client_id: str = "client-123",
    client_secret: str | None = None,
    token_endpoint_auth_method: str = "none",
    metadata_json: dict | None = None,
) -> MCPOAuthClient:
    client = MCPOAuthClient(
        mcp_server_id=server.id,
        issuer="https://auth.example.com",
        authorization_endpoint="https://auth.example.com/authorize",
        token_endpoint="https://auth.example.com/token",
        client_id=client_id,
        client_secret=client_secret,
        token_endpoint_auth_method=token_endpoint_auth_method,
        redirect_uri="https://xagent.example.com/api/mcp/oauth/callback",
        metadata_json=metadata_json,
    )
    db.add(client)
    db.flush()
    return client


def _association_generation(db, user: User, server: MCPServer):
    return (
        db.query(UserMCPServer.lifecycle_generation)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .scalar()
    )


def _add_callback_client_and_state(
    db,
    user: User,
    *,
    state: str,
    metadata_json: dict | None = None,
    redirect_after: str = "/mcp",
) -> tuple[MCPServer, MCPOAuthClient, MCPOAuthFlowState]:
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server, metadata_json=metadata_json)
    association_generation = _association_generation(db, user, server)
    flow_state = MCPOAuthFlowState(
        state=state,
        mcp_server_id=server.id,
        user_id=user.id,
        association_lifecycle_generation=association_generation,
        mcp_oauth_client_id=client.id,
        resource_owner_key=mcp_api._default_resource_owner_key(user.id),
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        code_verifier=mcp_api.encrypt_value("verifier-123"),
        redirect_after=redirect_after,
        expires_at=mcp_api._utc_now() + timedelta(minutes=10),
    )
    db.add(flow_state)
    db.commit()
    return server, client, flow_state


def _set_user_mcp_active(db, user: User, server: MCPServer, is_active: bool) -> None:
    user_mcp = (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one()
    )
    user_mcp.is_active = is_active
    db.commit()


def _allow_standalone_connector_delete(monkeypatch) -> None:
    monkeypatch.setattr(
        connector_team_scope,
        "delete_team_connector",
        lambda *args, **kwargs: SimpleNamespace(
            blocked_reason=None,
            team_owned=False,
            authorized=False,
            delete_definition=False,
        ),
    )


@pytest.mark.asyncio
async def test_get_mcp_server_tools_requires_oauth_grant_without_static_fallback(
    db_session,
    monkeypatch,
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    server.headers = {
        "Authorization": "Bearer static-token",
        "X-Request-Source": "xagent",
    }
    db.commit()

    async def fail_load_tools(*args, **kwargs):
        pytest.fail("MCP tools loader should not be called without an OAuth grant")

    monkeypatch.setattr(
        "xagent.core.tools.adapters.vibe.mcp_adapter.load_mcp_tools_as_agent_tools",
        fail_load_tools,
    )

    with pytest.raises(HTTPException) as exc_info:
        await get_mcp_server_tools(server.id, user, db)

    assert exc_info.value.status_code == 400
    assert exc_info.value.detail["code"] == "authorization_required"
    assert (
        exc_info.value.detail["message"]
        == "No active MCP OAuth grant exists for the selected resource owner"
    )


@pytest.mark.asyncio
async def test_get_mcp_server_tools_injects_runtime_oauth_grant(
    db_session,
    monkeypatch,
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    server.headers = {
        "Authorization": "Bearer static-token",
        "X-Request-Source": "xagent",
    }
    client = _add_oauth_client(db, server, client_id="client-123")
    grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=encrypt_value("runtime-token"),
        status="active",
    )
    db.add(grant)
    db.commit()
    captured_connections = []
    captured_connector_refs = []

    async def fake_load_tools(connections, name_prefix, connector_refs=None):
        captured_connections.append(connections)
        captured_connector_refs.append(connector_refs)
        return MCPLoadResult(
            tools=(
                SimpleNamespace(name="search_records", description="Search records"),
            ),
            loaded_servers=("records",),
            failures=(),
        )

    monkeypatch.setattr(
        "xagent.core.tools.adapters.vibe.mcp_adapter.load_mcp_tools_as_agent_tools",
        fake_load_tools,
    )

    response = await get_mcp_server_tools(server.id, user, db)

    assert response["tool_count"] == 1
    connection = captured_connections[0]["records"]
    assert connection["headers"]["Authorization"] == "Bearer runtime-token"
    assert connection["headers"]["X-Request-Source"] == "xagent"
    # This listing seam carries the persisted server id like every other MCP
    # materialization seam, so a gated call built here could never fail
    # closed for want of a connector identity; the transport mapping itself
    # stays id-free.
    assert captured_connector_refs[0] == {"records": ConnectorRef("mcp", server.id)}
    assert "id" not in connection


@pytest.mark.asyncio
async def test_get_mcp_server_tools_keeps_partial_tools_and_reports_safe_failures(
    db_session,
    monkeypatch,
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server, client_id="client-123")
    db.add(
        MCPOAuthGrant(
            mcp_server_id=server.id,
            user_id=user.id,
            mcp_oauth_client_id=client.id,
            resource_owner_key=f"xagent:user:{user.id}",
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="records.read",
            access_token=encrypt_value("runtime-token"),
            status="active",
        )
    )
    db.commit()

    async def partially_failed_load(*args, **kwargs):
        return MCPLoadResult(
            tools=(
                SimpleNamespace(name="search_records", description="Search records"),
            ),
            loaded_servers=("records",),
            failures=(
                MCPServerLoadFailure(
                    server_name="records",
                    phase=MCPFailurePhase.ADAPTER_CONSTRUCTION,
                    error_type="BearerSecretError",
                ),
            ),
        )

    monkeypatch.setattr(
        "xagent.core.tools.adapters.vibe.mcp_adapter.load_mcp_tools_as_agent_tools",
        partially_failed_load,
    )

    response = await get_mcp_server_tools(server.id, user, db)

    assert response == {
        "server_name": "records",
        "tool_count": 1,
        "tools": [
            {"name": "search_records", "description": "Search records"},
        ],
        "failures": [
            {
                "server_name": "records",
                "phase": "adapter_construction",
                "attempts": 1,
            }
        ],
    }
    assert "BearerSecretError" not in repr(response)


@pytest.mark.asyncio
async def test_get_mcp_server_tools_reports_structured_runtime_failure(
    db_session,
    monkeypatch,
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server, client_id="client-123")
    db.add(
        MCPOAuthGrant(
            mcp_server_id=server.id,
            user_id=user.id,
            mcp_oauth_client_id=client.id,
            resource_owner_key=f"xagent:user:{user.id}",
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="records.read",
            access_token=encrypt_value("runtime-token"),
            status="active",
        )
    )
    db.commit()

    async def failed_load(*args, **kwargs):
        return MCPLoadResult(
            tools=(),
            loaded_servers=(),
            failures=(
                MCPServerLoadFailure(
                    server_name="records",
                    phase=MCPFailurePhase.LIST_TOOLS,
                    error_type="BearerSecretError",
                ),
            ),
        )

    monkeypatch.setattr(
        "xagent.core.tools.adapters.vibe.mcp_adapter.load_mcp_tools_as_agent_tools",
        failed_load,
    )

    with pytest.raises(HTTPException) as exc_info:
        await get_mcp_server_tools(server.id, user, db)

    assert exc_info.value.status_code == 502
    assert exc_info.value.detail == {
        "code": "mcp_tools_unavailable",
        "message": "MCP server tools could not be loaded.",
        "failures": [{"server_name": "records", "phase": "list_tools", "attempts": 1}],
    }
    assert "BearerSecretError" not in repr(exc_info.value.detail)


@pytest.mark.asyncio
async def test_get_mcp_server_tools_rejects_inactive_user_server(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    _set_user_mcp_active(db, user, server, False)

    with pytest.raises(HTTPException) as exc_info:
        await get_mcp_server_tools(server.id, user, db)

    assert exc_info.value.status_code == 404


def test_update_mcp_server_can_reactivate_inactive_user_server(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    server.runtime_input_schema = {"context": {"account_id": {"type": "string"}}}
    server.runtime_bindings = [
        {
            "source": {"input_type": "context", "key": "account_id"},
            "target": {"target_type": "mcp_meta", "key": "account_id"},
        }
    ]
    server.allow_delegated_authorization = True
    db.commit()
    _set_user_mcp_active(db, user, server, False)

    response = update_mcp_server(
        server.id,
        MCPServerUpdate(description="Updated while inactive", is_active=True),
        user,
        db,
    )

    assert response.description == "Updated while inactive"
    assert response.is_active is True
    assert response.runtime_input_schema == {
        "context": {"account_id": {"type": "string"}}
    }
    assert response.runtime_bindings == [
        {
            "source": {"input_type": "context", "key": "account_id"},
            "target": {"target_type": "mcp_meta", "key": "account_id"},
        }
    ]
    assert response.allow_delegated_authorization is True


def test_update_mcp_server_persists_runtime_config(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)

    response = update_mcp_server(
        server.id,
        MCPServerUpdate(
            runtime_input_schema={"secrets": {"authorization": {"type": "string"}}},
            runtime_bindings=[
                {
                    "source": {"input_type": "secrets", "key": "authorization"},
                    "target": {
                        "target_type": "transport_headers",
                        "key": "Authorization",
                    },
                }
            ],
            allow_delegated_authorization=True,
        ),
        user,
        db,
    )

    assert response.runtime_input_schema == {
        "secrets": {"authorization": {"type": "string"}}
    }
    assert response.runtime_bindings == [
        {
            "source": {"input_type": "secrets", "key": "authorization"},
            "target": {
                "target_type": "transport_headers",
                "key": "Authorization",
            },
        }
    ]
    assert response.allow_delegated_authorization is True
    db.refresh(server)
    assert server.runtime_input_schema == response.runtime_input_schema
    assert server.runtime_bindings == response.runtime_bindings
    assert server.allow_delegated_authorization is True


def test_update_mcp_server_explicit_null_clears_runtime_config(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    server.runtime_input_schema = {"context": {"account_id": {"type": "string"}}}
    server.runtime_bindings = [
        {
            "source": {"input_type": "context", "key": "account_id"},
            "target": {"target_type": "mcp_meta", "key": "account_id"},
        }
    ]
    server.allow_delegated_authorization = True
    db.commit()

    response = update_mcp_server(
        server.id,
        MCPServerUpdate(
            runtime_input_schema=None,
            runtime_bindings=None,
            allow_delegated_authorization=False,
        ),
        user,
        db,
    )

    assert response.runtime_input_schema is None
    assert response.runtime_bindings is None
    assert response.allow_delegated_authorization is False
    db.refresh(server)
    assert server.runtime_input_schema is None
    assert server.runtime_bindings is None
    assert server.allow_delegated_authorization is False


def test_update_mcp_server_rejects_renamed_masked_global_env_key(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    encrypted_secret = encrypt_value("global-secret")
    server.env = {"TOKEN": encrypted_secret}
    db.commit()

    with pytest.raises(HTTPException) as exc_info:
        update_mcp_server(
            server.id,
            MCPServerUpdate(config={"env": {"RENAMED_TOKEN": "********"}}),
            user,
            db,
        )

    assert exc_info.value.status_code == 400
    db.refresh(server)
    assert server.env == {"TOKEN": encrypted_secret}


def test_update_mcp_server_rejects_renamed_masked_user_env_key(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    user_mcp = (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one()
    )
    encrypted_secret = encrypt_value("user-secret")
    user_mcp.env = {"TOKEN": encrypted_secret}
    db.commit()

    with pytest.raises(HTTPException) as exc_info:
        update_mcp_server(
            server.id,
            MCPServerUpdate(user_env={"RENAMED_TOKEN": "********"}),
            user,
            db,
        )

    assert exc_info.value.status_code == 400
    db.refresh(user_mcp)
    assert user_mcp.env == {"TOKEN": encrypted_secret}


@pytest.mark.asyncio
async def test_connect_creates_pkce_state_and_redirects(db_session, monkeypatch):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    server.headers = {"Authorization": "Bearer static-token"}
    db.commit()

    async def fake_discover(*args, **kwargs):
        assert kwargs["headers"] is None
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    response = await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
    )

    assert response.status_code == 303
    location = response.headers["location"]
    parsed = urlparse(location)
    query = parse_qs(parsed.query)
    assert f"{parsed.scheme}://{parsed.netloc}{parsed.path}" == (
        "https://auth.example.com/authorize"
    )
    assert query["response_type"] == ["code"]
    assert query["client_id"] == ["client-123"]
    assert query["redirect_uri"] == [
        "https://xagent.example.com/api/mcp/oauth/callback"
    ]
    assert query["resource"] == ["https://mcp.example.com/mcp"]
    assert query["scope"] == ["records.read"]
    assert query["code_challenge_method"] == ["S256"]
    assert "code_challenge" in query
    assert "code_verifier" not in query

    flow_state = db.query(MCPOAuthFlowState).one()
    assert flow_state.state == query["state"][0]
    assert flow_state.resource_owner_key == f"xagent:user:{user.id}"
    assert flow_state.redirect_after == "/settings/mcp"
    assert decrypt_value(flow_state.code_verifier) != flow_state.code_verifier

    client = db.query(MCPOAuthClient).one()
    assert client.client_id == "client-123"
    assert client.client_secret != "client-secret"
    assert decrypt_value(client.client_secret) == "client-secret"
    assert flow_state.mcp_oauth_client_id == client.id
    assert flow_state.association_lifecycle_generation == _association_generation(
        db, user, server
    )


@pytest.mark.asyncio
async def test_connect_rejects_delete_and_recreate_during_provider_io(
    db_session, monkeypatch
):
    db, user, other_user = db_session
    server = _add_mcp_oauth_server(db, user)
    db.add(
        UserMCPServer(
            user_id=other_user.id,
            mcpserver_id=server.id,
            is_owner=False,
            is_active=True,
        )
    )
    db.commit()
    original_generation = _association_generation(db, user, server)
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)

    async def replace_association_during_discovery(*args, **kwargs):
        other_db = SessionLocal()
        try:
            other_db.query(UserMCPServer).filter(
                UserMCPServer.user_id == user.id,
                UserMCPServer.mcpserver_id == server.id,
            ).delete(synchronize_session=False)
            other_db.commit()
            other_db.add(
                UserMCPServer(
                    user_id=user.id,
                    mcpserver_id=server.id,
                    is_owner=False,
                    is_active=True,
                )
            )
            other_db.commit()
        finally:
            other_db.close()
        return _discovery()

    monkeypatch.setattr(
        mcp_api, "discover_mcp_oauth_metadata", replace_association_during_discovery
    )

    with pytest.raises(HTTPException) as exc_info:
        await connect_mcp_oauth(
            server.id,
            MCPOAuthConnectRequest(redirect_after="/mcp"),
            user,
            db,
        )

    assert exc_info.value.status_code == 409
    assert exc_info.value.detail["code"] == "oauth_lifecycle_changed"
    db.expire_all()
    replacement_generation = _association_generation(db, user, server)
    assert replacement_generation != original_generation
    assert db.query(MCPOAuthClient).count() == 0
    assert db.query(MCPOAuthFlowState).count() == 0
    assert (
        db.query(UserMCPServer).filter(UserMCPServer.mcpserver_id == server.id).count()
        == 2
    )


def test_connect_producer_first_blocks_disconnect_until_flow_commit(
    db_session, monkeypatch
):
    db, user, other_user = db_session
    server = _add_mcp_oauth_server(db, user)
    db.add(
        UserMCPServer(
            user_id=other_user.id,
            mcpserver_id=server.id,
            is_owner=False,
            is_active=True,
        )
    )
    db.commit()
    association_identity = mcp_api._MCPOAuthAssociationIdentity(
        server_id=server.id,
        user_id=user.id,
        lifecycle_generation=_association_generation(db, user, server),
    )
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    disconnect_started = threading.Event()
    disconnect_finished = threading.Event()
    disconnect_errors: list[BaseException] = []

    def disconnect() -> None:
        other_db = SessionLocal()
        try:
            disconnect_started.set()
            asyncio.run(
                delete_mcp_server(
                    server.id,
                    current_user=other_db.get(User, user.id),
                    db=other_db,
                )
            )
        except BaseException as exc:  # pragma: no cover - assertion reports it
            disconnect_errors.append(exc)
        finally:
            other_db.close()
            disconnect_finished.set()

    original_upsert = mcp_api._upsert_mcp_oauth_client
    disconnect_thread: threading.Thread | None = None

    def gated_upsert(*args, **kwargs):
        nonlocal disconnect_thread
        disconnect_thread = threading.Thread(target=disconnect)
        disconnect_thread.start()
        assert disconnect_started.wait(timeout=2)
        time.sleep(0.1)
        assert not disconnect_finished.is_set()
        return original_upsert(*args, **kwargs)

    monkeypatch.setattr(mcp_api, "_upsert_mcp_oauth_client", gated_upsert)
    monkeypatch.setattr(
        connector_team_scope,
        "delete_team_connector",
        lambda *args, **kwargs: SimpleNamespace(
            blocked_reason=None,
            team_owned=False,
            authorized=False,
            delete_definition=False,
        ),
    )
    persisted = mcp_api._persist_mcp_oauth_connect_flow(
        db,
        association_identity=association_identity,
        discovery=_discovery(),
        client_id="client-123",
        client_secret=None,
        token_endpoint_auth_method="none",
        redirect_uri="https://xagent.example.com/api/mcp/oauth/callback",
        registration_lookup_hash=None,
        resource_owner_key=f"xagent:user:{user.id}",
        selected_issuer="https://auth.example.com",
        selected_resource="https://mcp.example.com/mcp",
        selected_scope="records.read",
        redirect_after="/mcp",
    )
    assert persisted is not None
    assert disconnect_thread is not None
    disconnect_thread.join(timeout=DB_PROGRESS_TIMEOUT)

    assert disconnect_finished.is_set()
    assert disconnect_errors == []
    db.expire_all()
    assert (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one_or_none()
        is None
    )
    assert db.query(MCPOAuthFlowState).count() == 0
    assert (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == other_user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one()
        is not None
    )


def test_callback_producer_first_blocks_real_disconnect_until_grant_commit(
    db_session, monkeypatch
):
    db, user, other_user = db_session
    server = _add_mcp_oauth_server(db, user)
    db.add(
        UserMCPServer(
            user_id=other_user.id,
            mcpserver_id=server.id,
            is_owner=False,
            is_active=True,
        )
    )
    client = _add_oauth_client(db, server)
    generation = _association_generation(db, user, server)
    flow = MCPOAuthFlowState(
        state="sqlite-producer-first",
        mcp_server_id=server.id,
        user_id=user.id,
        association_lifecycle_generation=generation,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        code_verifier=encrypt_value("sqlite-verifier"),
        expires_at=mcp_api._utc_now() + timedelta(minutes=10),
        consumed_at=mcp_api._utc_now(),
    )
    db.add(flow)
    db.commit()
    association_identity = mcp_api._MCPOAuthAssociationIdentity(
        server_id=server.id,
        user_id=user.id,
        lifecycle_generation=generation,
    )
    flow_identity = mcp_api._mcp_oauth_flow_identity(flow)
    lifecycle = mcp_api._lock_active_mcp_oauth_lifecycle(
        db,
        association_identity=association_identity,
        flow_identity=flow_identity,
    )
    assert lifecycle is not None and lifecycle[2] is not None

    monkeypatch.setattr(
        connector_team_scope,
        "delete_team_connector",
        lambda *args, **kwargs: SimpleNamespace(
            blocked_reason=None,
            team_owned=False,
            authorized=False,
            delete_definition=False,
        ),
    )
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    disconnect_started = threading.Event()
    disconnect_lock_attempted = threading.Event()
    disconnect_finished = threading.Event()
    disconnect_errors: list[BaseException] = []

    def disconnect() -> None:
        with SessionLocal() as disconnect_db:
            try:
                disconnect_started.set()
                asyncio.run(
                    delete_mcp_server(
                        server.id,
                        current_user=disconnect_db.get(User, user.id),
                        db=disconnect_db,
                    )
                )
            except BaseException as exc:  # pragma: no cover - assertion reports it
                disconnect_errors.append(exc)
            finally:
                disconnect_finished.set()

    disconnect_thread = threading.Thread(target=disconnect)
    original_lock = mcp_api._lock_active_mcp_oauth_lifecycle

    def record_disconnect_lock_attempt(*args, **kwargs):
        disconnect_lock_attempted.set()
        return original_lock(*args, **kwargs)

    monkeypatch.setattr(
        mcp_api,
        "_lock_active_mcp_oauth_lifecycle",
        record_disconnect_lock_attempt,
    )
    disconnect_thread.start()
    assert disconnect_started.wait(timeout=2)
    assert disconnect_lock_attempted.wait(timeout=DB_PROGRESS_TIMEOUT)
    assert not disconnect_finished.wait(timeout=0.2)
    mcp_api._upsert_mcp_oauth_grant(
        db,
        flow_state=lifecycle[2],
        token_data={
            "access_token": "sqlite-issued-token",
            "token_type": "Bearer",
            "scope": "records.read",
        },
    )
    db.commit()

    disconnect_thread.join(timeout=DB_PROGRESS_TIMEOUT)
    assert disconnect_finished.is_set()
    assert disconnect_errors == []
    db.expire_all()
    assert db.query(MCPOAuthGrant).count() == 0
    assert db.query(MCPOAuthFlowState).count() == 0
    assert (
        db.query(UserMCPServer).filter(UserMCPServer.mcpserver_id == server.id).count()
        == 1
    )


def test_real_disconnect_first_rejects_stale_callback_and_preserves_replacement(
    db_session, monkeypatch
):
    db, user, other_user = db_session
    server = _add_mcp_oauth_server(db, user)
    db.add(
        UserMCPServer(
            user_id=other_user.id,
            mcpserver_id=server.id,
            is_owner=False,
            is_active=True,
        )
    )
    client = _add_oauth_client(db, server)
    original_generation = _association_generation(db, user, server)
    flow = MCPOAuthFlowState(
        state="sqlite-teardown-first",
        mcp_server_id=server.id,
        user_id=user.id,
        association_lifecycle_generation=original_generation,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        code_verifier=encrypt_value("sqlite-verifier"),
        expires_at=mcp_api._utc_now() + timedelta(minutes=10),
        consumed_at=mcp_api._utc_now(),
    )
    db.add(flow)
    db.commit()
    association_identity = mcp_api._MCPOAuthAssociationIdentity(
        server_id=server.id,
        user_id=user.id,
        lifecycle_generation=original_generation,
    )
    flow_identity = mcp_api._mcp_oauth_flow_identity(flow)
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    teardown_locked = threading.Event()
    allow_teardown = threading.Event()
    producer_started = threading.Event()
    producer_finished = threading.Event()
    producer_results: list[object] = []
    errors: list[BaseException] = []

    def gated_team_delete(*args, **kwargs):
        teardown_locked.set()
        assert allow_teardown.wait(timeout=DB_PROGRESS_TIMEOUT)
        return SimpleNamespace(
            blocked_reason=None,
            team_owned=False,
            authorized=False,
            delete_definition=False,
        )

    monkeypatch.setattr(
        connector_team_scope, "delete_team_connector", gated_team_delete
    )

    def disconnect() -> None:
        with SessionLocal() as disconnect_db:
            try:
                asyncio.run(
                    delete_mcp_server(
                        server.id,
                        current_user=disconnect_db.get(User, user.id),
                        db=disconnect_db,
                    )
                )
            except BaseException as exc:  # pragma: no cover - assertion reports it
                errors.append(exc)

    def producer() -> None:
        with SessionLocal() as producer_db:
            try:
                producer_started.set()
                producer_results.append(
                    mcp_api._lock_active_mcp_oauth_lifecycle(
                        producer_db,
                        association_identity=association_identity,
                        flow_identity=flow_identity,
                    )
                )
                producer_db.rollback()
            except BaseException as exc:  # pragma: no cover - assertion reports it
                errors.append(exc)
            finally:
                producer_finished.set()

    disconnect_thread = threading.Thread(target=disconnect)
    disconnect_thread.start()
    assert teardown_locked.wait(timeout=DB_PROGRESS_TIMEOUT)
    producer_thread = threading.Thread(target=producer)
    producer_thread.start()
    assert producer_started.wait(timeout=2)
    assert not producer_finished.wait(timeout=0.2)
    allow_teardown.set()
    disconnect_thread.join(timeout=DB_PROGRESS_TIMEOUT)
    producer_thread.join(timeout=DB_PROGRESS_TIMEOUT)
    assert errors == []
    assert producer_finished.is_set()
    assert producer_results == [None]

    db.expire_all()
    replacement = UserMCPServer(
        user_id=user.id,
        mcpserver_id=server.id,
        is_owner=False,
        is_active=True,
    )
    db.add(replacement)
    db.commit()
    assert replacement.lifecycle_generation != original_generation
    assert (
        mcp_api._lock_active_mcp_oauth_lifecycle(
            db,
            association_identity=association_identity,
            flow_identity=flow_identity,
        )
        is None
    )
    db.rollback()
    assert db.query(MCPOAuthGrant).count() == 0
    assert db.query(MCPOAuthFlowState).count() == 0
    assert (
        db.query(UserMCPServer).filter(UserMCPServer.mcpserver_id == server.id).count()
        == 2
    )


@pytest.mark.asyncio
async def test_stale_real_disconnect_cannot_delete_replacement_association(
    db_session, monkeypatch
):
    db, user, other_user = db_session
    server = _add_mcp_oauth_server(db, user)
    db.add(
        UserMCPServer(
            user_id=other_user.id,
            mcpserver_id=server.id,
            is_owner=False,
            is_active=True,
        )
    )
    db.commit()
    original_generation = _association_generation(db, user, server)
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    original_lock = mcp_api._lock_active_mcp_oauth_lifecycle
    replacement_generation: list[object] = []

    def replace_before_lock(*args, **kwargs):
        with SessionLocal() as replacement_db:
            replacement_db.query(UserMCPServer).filter(
                UserMCPServer.user_id == user.id,
                UserMCPServer.mcpserver_id == server.id,
                UserMCPServer.lifecycle_generation == original_generation,
            ).delete(synchronize_session=False)
            replacement = UserMCPServer(
                user_id=user.id,
                mcpserver_id=server.id,
                is_owner=True,
                is_active=True,
            )
            replacement_db.add(replacement)
            replacement_db.commit()
            replacement_generation.append(replacement.lifecycle_generation)
        return original_lock(*args, **kwargs)

    monkeypatch.setattr(
        mcp_api, "_lock_active_mcp_oauth_lifecycle", replace_before_lock
    )

    with pytest.raises(HTTPException) as exc_info:
        await delete_mcp_server(server.id, current_user=user, db=db)

    assert exc_info.value.status_code == 404
    assert replacement_generation[0] != original_generation
    db.expire_all()
    replacement = (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one()
    )
    assert replacement.lifecycle_generation == replacement_generation[0]
    assert (
        db.query(UserMCPServer).filter(UserMCPServer.mcpserver_id == server.id).count()
        == 2
    )


@pytest.mark.asyncio
async def test_real_disconnect_uses_generation_when_active_state_changes_before_lock(
    db_session, monkeypatch
):
    db, user, other_user = db_session
    server = _add_mcp_oauth_server(db, user)
    db.add(
        UserMCPServer(
            user_id=other_user.id,
            mcpserver_id=server.id,
            is_owner=False,
            is_active=True,
        )
    )
    db.commit()
    server_id = int(server.id)
    user_id = int(user.id)
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    original_lock = mcp_api._lock_active_mcp_oauth_lifecycle
    toggled = False

    def deactivate_before_lock(*args, **kwargs):
        nonlocal toggled
        if not toggled:
            toggled = True
            with SessionLocal() as toggle_db:
                toggle_db.query(UserMCPServer).filter(
                    UserMCPServer.user_id == user_id,
                    UserMCPServer.mcpserver_id == server_id,
                ).update(
                    {UserMCPServer.is_active: False},
                    synchronize_session=False,
                )
                toggle_db.commit()
        return original_lock(*args, **kwargs)

    monkeypatch.setattr(
        mcp_api, "_lock_active_mcp_oauth_lifecycle", deactivate_before_lock
    )
    _allow_standalone_connector_delete(monkeypatch)

    await delete_mcp_server(server_id, current_user=user, db=db)

    assert toggled is True
    db.expire_all()
    assert (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user_id,
            UserMCPServer.mcpserver_id == server_id,
        )
        .one_or_none()
        is None
    )
    assert (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == other_user.id,
            UserMCPServer.mcpserver_id == server_id,
        )
        .one()
        is not None
    )


@pytest.mark.asyncio
async def test_last_user_disconnect_deletes_server_before_post_commit_reconnect(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    server_id = int(server.id)
    user_id = int(user.id)
    client = _add_oauth_client(
        db,
        server,
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    generation = _association_generation(db, user, server)
    db.add_all(
        [
            MCPOAuthFlowState(
                state="last-user-flow",
                mcp_server_id=server_id,
                user_id=user_id,
                association_lifecycle_generation=generation,
                mcp_oauth_client_id=client.id,
                resource_owner_key=f"xagent:user:{user_id}",
                issuer="https://auth.example.com",
                resource="https://mcp.example.com/mcp",
                scope="records.read",
                code_verifier=encrypt_value("last-user-verifier"),
                expires_at=mcp_api._utc_now() + timedelta(minutes=10),
            ),
            MCPOAuthGrant(
                mcp_server_id=server_id,
                user_id=user_id,
                mcp_oauth_client_id=client.id,
                resource_owner_key=f"xagent:user:{user_id}",
                issuer="https://auth.example.com",
                resource="https://mcp.example.com/mcp",
                scope="records.read",
                access_token=encrypt_value("last-user-token"),
                status="active",
            ),
        ]
    )
    db.commit()
    engine = db.get_bind()

    @event.listens_for(engine, "connect")
    def enable_foreign_keys(dbapi_connection, _connection_record):
        cursor = dbapi_connection.cursor()
        try:
            cursor.execute("PRAGMA foreign_keys=ON")
        finally:
            cursor.close()

    db.connection().exec_driver_sql("PRAGMA foreign_keys=ON")
    assert db.connection().exec_driver_sql("PRAGMA foreign_keys").scalar() == 1
    db.rollback()
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    replacement_committed: list[bool] = []
    main_commits: list[None] = []

    @event.listens_for(db, "after_commit")
    def record_main_commit(session):
        main_commits.append(None)

    async def reconnect_after_local_commit(snapshot):
        assert not db.in_transaction()
        with SessionLocal() as reconnect_db:
            reconnect_db.add(
                UserMCPServer(
                    user_id=user_id,
                    mcpserver_id=server_id,
                    is_owner=False,
                    is_active=True,
                )
            )
            try:
                reconnect_db.commit()
            except IntegrityError:
                reconnect_db.rollback()
                replacement_committed.append(False)
            else:  # pragma: no cover - the assertion below reports the regression
                replacement_committed.append(True)

    monkeypatch.setattr(
        mcp_api,
        "_revoke_mcp_oauth_grant_snapshot_externally",
        reconnect_after_local_commit,
    )
    _allow_standalone_connector_delete(monkeypatch)

    await delete_mcp_server(server_id, current_user=user, db=db)

    assert replacement_committed == [False]
    assert len(main_commits) == 1
    db.expire_all()
    assert db.query(MCPServer).filter(MCPServer.id == server_id).count() == 0
    assert (
        db.query(UserMCPServer).filter(UserMCPServer.mcpserver_id == server_id).count()
        == 0
    )
    assert (
        db.query(MCPOAuthGrant).filter(MCPOAuthGrant.mcp_server_id == server_id).count()
        == 0
    )
    assert (
        db.query(MCPOAuthFlowState)
        .filter(MCPOAuthFlowState.mcp_server_id == server_id)
        .count()
        == 0
    )


@pytest.mark.asyncio
async def test_connect_sweeps_flow_states_expired_past_the_retention_window(
    db_session, monkeypatch
):
    db, user, other_user = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    # A second server, so the fixtures below can pin the sweep as global across
    # servers and not just across users. Its own client row keeps the
    # mcp_oauth_client_id FK pointing at the matching server.
    other_server = _add_mcp_oauth_server(db, other_user, name="records-2")
    other_client = _add_oauth_client(db, other_server)
    db.commit()

    now = mcp_api._utc_now()
    # Deliberately literal rather than derived from
    # MCP_OAUTH_FLOW_STATE_RETENTION: the one-day policy is the contract under
    # test, and a fixture computed from the production constant would follow it
    # anywhere it moved and stay green while the contract silently changed.
    one_day = timedelta(days=1)

    def _flow_state(
        state: str,
        owner: User,
        expires_at,
        *,
        target: MCPServer = server,
        oauth_client: MCPOAuthClient = client,
        consumed_at=None,
    ) -> MCPOAuthFlowState:
        return MCPOAuthFlowState(
            state=state,
            mcp_server_id=target.id,
            user_id=owner.id,
            mcp_oauth_client_id=oauth_client.id,
            resource_owner_key=f"xagent:user:{owner.id}",
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="records.read",
            code_verifier=encrypt_value("verifier-123"),
            expires_at=expires_at,
            consumed_at=consumed_at,
        )

    db.add_all(
        [
            # Abandoned past the retention window — the row the sweep exists
            # for. Owned by the *other* user, so this pins the sweep as global
            # across users: scoping it to the connecting user would leave the
            # rows of anyone who never reconnects in the table forever, which
            # is the leak being closed.
            _flow_state(
                "stale-other-user", other_user, now - one_day - timedelta(hours=1)
            ),
            # Same, on a server this connect is not touching — pins the sweep
            # as global across servers too.
            _flow_state(
                "stale-other-server",
                other_user,
                now - one_day - timedelta(hours=1),
                target=other_server,
                oauth_client=other_client,
            ),
            # A completed authorization's row. Nothing filters on consumed_at,
            # and it must not need to: a consumed row expires on the same
            # schedule as any other, so the expires_at predicate has to reach
            # it as well.
            _flow_state(
                "stale-consumed",
                user,
                now - one_day - timedelta(hours=1),
                consumed_at=now - one_day - timedelta(hours=1),
            ),
            # The fresh side of the same boundary: expired 23 hours ago, so
            # already unusable (the claim query requires expires_at > now) but
            # still inside the one-day window, and therefore kept. The grace
            # period is what keeps the sweep clear of any callback still racing
            # to claim its row.
            _flow_state(
                "expired-inside-window", user, now - one_day + timedelta(hours=1)
            ),
            # Another authorization still in progress.
            _flow_state("in-flight", other_user, now + mcp_api.MCP_OAUTH_STATE_TTL),
        ]
    )
    db.commit()

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    ordering: list[str] = []
    original_sweep = mcp_api._sweep_expired_mcp_oauth_flow_states
    original_lock = mcp_api._lock_active_mcp_oauth_lifecycle

    def record_sweep(*args, **kwargs):
        ordering.append("sweep")
        return original_sweep(*args, **kwargs)

    def record_lock(*args, **kwargs):
        ordering.append("lifecycle_lock")
        return original_lock(*args, **kwargs)

    monkeypatch.setattr(mcp_api, "_sweep_expired_mcp_oauth_flow_states", record_sweep)
    monkeypatch.setattr(mcp_api, "_lock_active_mcp_oauth_lifecycle", record_lock)

    response = await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(redirect_after="/mcp"),
        user,
        db,
    )

    assert response.status_code == 303
    surviving = {row.state for row in db.query(MCPOAuthFlowState).all()}
    assert not (
        {"stale-other-user", "stale-other-server", "stale-consumed"} & surviving
    )
    assert {"expired-inside-window", "in-flight"} <= surviving
    assert ordering[:2] == ["sweep", "lifecycle_lock"]
    # The independent maintenance commit cannot consume the new flow because
    # lifecycle persistence starts only after the sweep has completed.
    assert _redirect_query(response)["state"][0] in surviving


@pytest.mark.asyncio
async def test_connect_sweep_is_bounded_and_drains_across_requests(
    db_session, monkeypatch
):
    # The sweep runs as a short maintenance transaction in a user-facing
    # request. The batch cap keeps the first connect after an accumulated
    # backlog from draining it all at once; later connects drain the remainder.
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    db.commit()

    monkeypatch.setattr(mcp_api, "MCP_OAUTH_FLOW_STATE_SWEEP_BATCH", 2)
    stale_at = mcp_api._utc_now() - timedelta(days=1) - timedelta(hours=1)
    db.add_all(
        [
            MCPOAuthFlowState(
                state=f"stale-{index}",
                mcp_server_id=server.id,
                user_id=user.id,
                mcp_oauth_client_id=client.id,
                resource_owner_key=f"xagent:user:{user.id}",
                issuer="https://auth.example.com",
                resource="https://mcp.example.com/mcp",
                scope="records.read",
                code_verifier=encrypt_value("verifier-123"),
                expires_at=stale_at,
            )
            for index in range(5)
        ]
    )
    db.commit()

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    def _remaining_stale() -> int:
        return (
            db.query(MCPOAuthFlowState)
            .filter(MCPOAuthFlowState.state.like("stale-%"))
            .count()
        )

    async def _connect() -> None:
        await connect_mcp_oauth(
            server.id,
            MCPOAuthConnectRequest(redirect_after="/mcp"),
            user,
            db,
        )

    await _connect()
    assert _remaining_stale() == 3

    await _connect()
    assert _remaining_stale() == 1

    await _connect()
    assert _remaining_stale() == 0


@pytest.mark.asyncio
async def test_connect_dynamically_registers_public_client_when_client_id_is_empty(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(
        db,
        user,
        client_id="",
        client_secret=None,
        redirect_uri=None,
        token_endpoint_auth_method="none",
    )
    monkeypatch.setenv("XAGENT_PUBLIC_API_BASE_URL", "https://api.xagent.test/")

    async def fake_discover(*args, **kwargs):
        return _discovery()

    registration_requests: list[httpx.Request] = []

    def registration_handler(request: httpx.Request) -> httpx.Response:
        registration_requests.append(request)
        return httpx.Response(
            201,
            json={
                "client_id": "dynamic-client-123",
                "token_endpoint_auth_method": "none",
            },
        )

    registration_client = httpx.AsyncClient(
        transport=httpx.MockTransport(registration_handler)
    )
    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(
        mcp_oauth_service,
        "create_mcp_oauth_http_client",
        lambda **kwargs: registration_client,
    )

    response = await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
    )

    query = parse_qs(urlparse(response.headers["location"]).query)
    assert query["client_id"] == ["dynamic-client-123"]
    assert query["redirect_uri"] == ["https://api.xagent.test/api/mcp/oauth/callback"]
    assert len(registration_requests) == 1
    assert str(registration_requests[0].url) == "https://auth.example.com/register"
    assert json.loads(registration_requests[0].content) == {
        "application_type": "web",
        "client_name": "Xagent",
        "grant_types": ["authorization_code", "refresh_token"],
        "redirect_uris": ["https://api.xagent.test/api/mcp/oauth/callback"],
        "response_types": ["code"],
        "token_endpoint_auth_method": "none",
    }
    client = db.query(MCPOAuthClient).one()
    assert client.client_id == "dynamic-client-123"
    assert client.client_secret is None
    assert client.token_endpoint_auth_method == "none"

    second_response = await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
    )
    second_query = parse_qs(urlparse(second_response.headers["location"]).query)
    assert second_query["client_id"] == ["dynamic-client-123"]
    assert len(registration_requests) == 1
    assert db.query(MCPOAuthClient).count() == 1


def test_default_mcp_oauth_redirect_uri_prefers_public_api_base(monkeypatch):
    monkeypatch.setenv("XAGENT_PUBLIC_API_BASE_URL", "https://api.xagent.test/base/")
    monkeypatch.setenv("XAGENT_APP_BASE_URL", "https://frontend.xagent.test/")

    assert mcp_api._default_mcp_oauth_redirect_uri() == (
        "https://api.xagent.test/base/api/mcp/oauth/callback"
    )


@pytest.mark.asyncio
async def test_connect_without_client_id_or_registration_endpoint_requires_preregistration(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(
        db,
        user,
        client_id="",
        client_secret=None,
        token_endpoint_auth_method="none",
    )

    async def fake_discover(*args, **kwargs):
        discovery = _discovery()
        discovery.authorization_server.registration_endpoint = None
        return discovery

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    with pytest.raises(HTTPException) as exc:
        await connect_mcp_oauth(
            server.id,
            MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
            user,
            db,
        )

    assert exc.value.status_code == 400
    assert exc.value.detail == {
        "code": "client_registration_unavailable",
        "message": (
            "Authorization server does not support dynamic client registration; "
            "configure a pre-registered MCP OAuth client_id"
        ),
    }


def test_upsert_oauth_client_preserves_existing_masked_client_secret(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    existing = _add_oauth_client(
        db,
        server,
        client_secret=encrypt_value("client-secret"),
        token_endpoint_auth_method="client_secret_post",
    )
    db.commit()

    client = mcp_api._upsert_mcp_oauth_client(
        db,
        server_id=server.id,
        discovery=_discovery(),
        client_id="client-123",
        client_secret=mcp_api.MASKED_SECRET_VALUE,
        token_endpoint_auth_method="client_secret_basic",
        redirect_uri="https://xagent.example.com/api/mcp/oauth/callback",
    )

    assert client.id == existing.id
    assert decrypt_value(client.client_secret) == "client-secret"
    assert client.token_endpoint_auth_method == "client_secret_basic"


def test_upsert_oauth_client_recovers_from_concurrent_insert(db_session, monkeypatch):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    real_flush = db.flush
    flush_calls = 0

    def fail_first_flush_after_concurrent_insert(*args, **kwargs):
        nonlocal flush_calls
        if flush_calls == 0:
            flush_calls += 1
            concurrent_db = SessionLocal()
            try:
                concurrent_client = MCPOAuthClient(
                    mcp_server_id=server.id,
                    issuer="https://auth.example.com",
                    authorization_endpoint="https://auth.example.com/authorize-old",
                    token_endpoint="https://auth.example.com/token-old",
                    client_id="client-123",
                    token_endpoint_auth_method="none",
                    redirect_uri="https://xagent.example.com/api/mcp/oauth/callback",
                )
                concurrent_db.add(concurrent_client)
                concurrent_db.commit()
            finally:
                concurrent_db.close()
            raise IntegrityError("insert", {}, Exception("duplicate lookup_hash"))
        return real_flush(*args, **kwargs)

    monkeypatch.setattr(db, "flush", fail_first_flush_after_concurrent_insert)

    client = mcp_api._upsert_mcp_oauth_client(
        db,
        server_id=server.id,
        discovery=_discovery(),
        client_id="client-123",
        client_secret="client-secret",
        token_endpoint_auth_method="client_secret_post",
        redirect_uri="https://xagent.example.com/api/mcp/oauth/callback",
    )

    assert client.id is not None
    assert client.authorization_endpoint == "https://auth.example.com/authorize"
    assert client.token_endpoint == "https://auth.example.com/token"
    assert client.token_endpoint_auth_method == "client_secret_post"
    assert decrypt_value(client.client_secret) == "client-secret"


def test_dynamic_client_conflict_adopts_registered_winner(db_session, monkeypatch):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user, client_id="", client_secret=None)
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    real_flush = db.flush
    registration_lookup_hash = mcp_oauth_client_registration_lookup_hash(
        server.id,
        "https://auth.example.com",
        "https://xagent.example.com/api/mcp/oauth/callback",
    )
    flush_calls = 0

    def insert_winner_before_first_flush(*args, **kwargs):
        nonlocal flush_calls
        if flush_calls == 0:
            flush_calls += 1
            concurrent_db = SessionLocal()
            try:
                concurrent_db.add(
                    MCPOAuthClient(
                        mcp_server_id=server.id,
                        registration_lookup_hash=registration_lookup_hash,
                        issuer="https://auth.example.com",
                        authorization_endpoint="https://auth.example.com/authorize",
                        token_endpoint="https://auth.example.com/token",
                        client_id="winner-client",
                        token_endpoint_auth_method="none",
                        redirect_uri=(
                            "https://xagent.example.com/api/mcp/oauth/callback"
                        ),
                    )
                )
                concurrent_db.commit()
            finally:
                concurrent_db.close()
            raise IntegrityError("insert", {}, Exception("duplicate registration"))
        return real_flush(*args, **kwargs)

    monkeypatch.setattr(db, "flush", insert_winner_before_first_flush)

    client = mcp_api._upsert_mcp_oauth_client(
        db,
        server_id=server.id,
        discovery=_discovery(),
        client_id="loser-client",
        client_secret=None,
        token_endpoint_auth_method="none",
        redirect_uri="https://xagent.example.com/api/mcp/oauth/callback",
        registration_lookup_hash=registration_lookup_hash,
    )

    assert client.client_id == "winner-client"
    assert db.query(MCPOAuthClient).count() == 1


def test_upsert_oauth_client_rejects_masked_client_secret_without_existing_value(
    db_session,
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)

    with pytest.raises(HTTPException) as exc:
        mcp_api._upsert_mcp_oauth_client(
            db,
            server_id=server.id,
            discovery=_discovery(),
            client_id="client-123",
            client_secret=mcp_api.MASKED_SECRET_VALUE,
            token_endpoint_auth_method="client_secret_post",
            redirect_uri="https://xagent.example.com/api/mcp/oauth/callback",
        )

    assert exc.value.detail["code"] == "invalid_resource"


def test_oauth_api_length_constants_match_schema():
    assert MCP_OAUTH_TOKEN_ENDPOINT_AUTH_METHOD_MAX_LENGTH == 100
    assert MCP_OAUTH_RESOURCE_OWNER_KEY_MAX_LENGTH == 512


@pytest.mark.asyncio
async def test_connect_canonicalizes_scope_before_persisting_flow_state(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(
        db,
        user,
        scope="records.write records.read records.write",
    )

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    response = await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
    )

    query = parse_qs(urlparse(response.headers["location"]).query)
    assert query["scope"] == ["records.read records.write"]
    assert db.query(MCPOAuthFlowState).one().scope == "records.read records.write"


@pytest.mark.asyncio
async def test_connect_rejects_scope_that_cannot_fit_grant_lookup_key(
    db_session, monkeypatch
):
    db, user, _ = db_session
    oversized_scope = "scope-" + "x" * MCP_OAUTH_SCOPE_MAX_LENGTH
    server = _add_mcp_oauth_server(db, user, scope=oversized_scope)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    with pytest.raises(HTTPException) as exc:
        await connect_mcp_oauth(
            server.id,
            MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
            user,
            db,
        )

    assert exc.value.status_code == 400
    assert exc.value.detail["code"] == "invalid_scope"
    assert db.query(MCPOAuthFlowState).count() == 0


@pytest.mark.asyncio
async def test_connect_rejects_client_id_that_cannot_fit_persistence(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(
        db,
        user,
        client_id="client-" + "x" * MCP_OAUTH_PERSISTED_VALUE_MAX_LENGTH,
    )

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    with pytest.raises(HTTPException) as exc:
        await connect_mcp_oauth(
            server.id,
            MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
            user,
            db,
        )

    assert exc.value.status_code == 400
    assert exc.value.detail["code"] == "invalid_resource"
    assert db.query(MCPOAuthClient).count() == 0
    assert db.query(MCPOAuthFlowState).count() == 0


@pytest.mark.asyncio
async def test_connect_sanitizes_backslash_redirect_after(db_session, monkeypatch):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(redirect_after="/\\evil.example.com"),
        user,
        db,
    )

    flow_state = db.query(MCPOAuthFlowState).one()
    assert flow_state.redirect_after == "/tools"


@pytest.mark.asyncio
async def test_connect_sanitizes_oversized_redirect_after(db_session, monkeypatch):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(
            redirect_after="/" + "x" * MCP_OAUTH_PERSISTED_VALUE_MAX_LENGTH
        ),
        user,
        db,
    )

    assert db.query(MCPOAuthFlowState).one().redirect_after == "/tools"


@pytest.mark.asyncio
async def test_connect_merges_authorization_endpoint_query_and_preserves_fragment(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)

    async def fake_discover(*args, **kwargs):
        discovery = _discovery()
        discovery.authorization_server.authorization_endpoint = (
            "https://auth.example.com/authorize?prompt=consent#login"
        )
        return discovery

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    response = await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
        accept="application/json",
    )

    payload = json.loads(response.body)
    parsed = urlparse(payload["authorization_url"])
    query = parse_qs(parsed.query)
    assert f"{parsed.scheme}://{parsed.netloc}{parsed.path}" == (
        "https://auth.example.com/authorize"
    )
    assert query["prompt"] == ["consent"]
    assert query["client_id"] == ["client-123"]
    assert query["resource"] == ["https://mcp.example.com/mcp"]
    assert parsed.fragment == "login"


def test_connect_request_rejects_public_resource_owner_key():
    with pytest.raises(ValueError):
        MCPOAuthConnectRequest.model_validate(
            {
                "redirect_after": "/settings/mcp",
                "resource_owner_key": "external:public-request",
            }
        )


def test_oauth_request_models_reject_public_config_overrides():
    public_overrides = {
        "resource": "https://other-resource.example.com/mcp",
        "issuer": "https://other-auth.example.com",
        "scope": "records.admin",
        "resource_metadata_url": "https://other-resource.example.com/.well-known/oauth-protected-resource",
    }

    with pytest.raises(ValueError):
        MCPOAuthDiscoverRequest.model_validate(public_overrides)
    with pytest.raises(ValueError):
        MCPOAuthConnectRequest.model_validate(
            {
                **public_overrides,
                "redirect_after": "/settings/mcp",
            }
        )


@pytest.mark.asyncio
async def test_connect_can_return_authorization_url_json(db_session, monkeypatch):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    response = await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
        accept="application/json",
    )

    payload = json.loads(response.body)
    authorization_url = payload["authorization_url"]
    parsed = urlparse(authorization_url)
    query = parse_qs(parsed.query)
    assert f"{parsed.scheme}://{parsed.netloc}{parsed.path}" == (
        "https://auth.example.com/authorize"
    )
    assert query["client_id"] == ["client-123"]
    assert query["resource"] == ["https://mcp.example.com/mcp"]
    assert db.query(MCPOAuthFlowState).count() == 1


@pytest.mark.asyncio
async def test_oauth_routes_allow_websocket_transport(db_session, monkeypatch):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user, transport="websocket")

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    discovery_response = await discover_mcp_oauth(
        server.id,
        MCPOAuthDiscoverRequest(),
        user,
        db,
    )
    assert discovery_response.issuer == "https://auth.example.com"

    connect_response = await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
    )

    assert connect_response.status_code == 303
    assert db.query(MCPOAuthFlowState).count() == 1


@pytest.mark.asyncio
async def test_oauth_routes_reject_inactive_user_mcp_server(db_session, monkeypatch):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    _set_user_mcp_active(db, user, server, False)

    async def fail_discover(*args, **kwargs):
        pytest.fail("inactive MCP server must not run OAuth discovery")

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fail_discover)

    with pytest.raises(mcp_api.HTTPException) as exc:
        await discover_mcp_oauth(
            server.id,
            MCPOAuthDiscoverRequest(),
            user,
            db,
        )
    assert exc.value.status_code == 404

    with pytest.raises(mcp_api.HTTPException) as exc:
        await connect_mcp_oauth(
            server.id,
            MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
            user,
            db,
        )
    assert exc.value.status_code == 404

    with pytest.raises(mcp_api.HTTPException) as exc:
        await get_mcp_oauth_status(server.id, user, db)
    assert exc.value.status_code == 404

    client = _add_oauth_client(db, server)
    grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=mcp_api.encrypt_value("own-access-token"),
    )
    db.add(grant)
    db.commit()
    db.refresh(grant)

    with pytest.raises(mcp_api.HTTPException) as exc:
        await delete_mcp_oauth_grant(server.id, grant.id, user, db)
    assert exc.value.status_code == 404


def _add_remote_oauth_catalog_app(db, *, app_id: str = "remote-notes") -> None:
    """A built-in catalog row shaped like a real remote-MCP-OAuth connector:
    only a URL and auth.type — no static client_id, matching a DCR-only
    provider (e.g. Granola) that never hands out pre-registered credentials.

    The synthetic app_id must NOT match a real builtin registry entry: the
    builtin execution overlay (get_builtin_execution_fields) replaces a DB
    row's execution fields with the canonical registry values for matching
    app_ids, which would silently override this fixture's url/auth."""
    db.add(
        PublicMCPApp(
            app_id=app_id,
            name=app_id.title(),
            transport="streamable_http",
            launch_config={
                "url": "https://mcp.example.com/mcp",
                "auth": {"type": "mcp_oauth"},
            },
        )
    )
    db.commit()


@pytest.mark.asyncio
async def test_connect_app_creates_server_and_association_then_starts_dcr_flow(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _add_remote_oauth_catalog_app(db)
    monkeypatch.setenv("XAGENT_PUBLIC_API_BASE_URL", "https://api.xagent.test/")

    async def fake_discover(*args, **kwargs):
        return _discovery()

    registration_requests: list[httpx.Request] = []

    def registration_handler(request: httpx.Request) -> httpx.Response:
        registration_requests.append(request)
        return httpx.Response(
            201,
            json={
                "client_id": "dynamic-client-123",
                "token_endpoint_auth_method": "none",
            },
        )

    registration_client = httpx.AsyncClient(
        transport=httpx.MockTransport(registration_handler)
    )
    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(
        mcp_oauth_service,
        "create_mcp_oauth_http_client",
        lambda **kwargs: registration_client,
    )

    response = await connect_mcp_oauth_app(
        "remote-notes",
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
    )

    assert response.status_code == 303
    query = parse_qs(urlparse(response.headers["location"]).query)
    assert query["client_id"] == ["dynamic-client-123"]
    assert len(registration_requests) == 1

    server = db.query(MCPServer).filter(MCPServer.name == "remote-notes").one()
    assert server.transport == "streamable_http"
    assert server.url == "https://mcp.example.com/mcp"
    assert server.auth["type"] == "mcp_oauth"

    assoc = (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id, UserMCPServer.mcpserver_id == server.id
        )
        .one()
    )
    assert assoc.is_active is True
    assert assoc.is_owner is False


@pytest.mark.asyncio
async def test_connect_hubspot_app_uses_static_client_credentials(
    db_session, monkeypatch
):
    db, user, _ = db_session
    app = get_builtin_public_mcp_app("hubspot")
    assert app is not None
    db.add(
        PublicMCPApp(
            app_id="hubspot",
            name=app["name"],
            description=app["description"],
            transport=app["transport"],
            provider_name=app["provider_name"],
            category=app["category"],
            oauth_scopes=app["oauth_scopes"],
            launch_config=app["launch_config"],
            is_visible_in_connector=True,
        )
    )
    db.commit()
    monkeypatch.setenv("XAGENT_HUBSPOT_MCP_CLIENT_ID", "hubspot-client")
    monkeypatch.setenv("XAGENT_HUBSPOT_MCP_CLIENT_SECRET", "hubspot-secret")
    monkeypatch.setenv("XAGENT_PUBLIC_API_BASE_URL", "https://api.xagent.test")

    async def fake_discover(*args, **kwargs):
        return _discovery()

    async def fail_dcr(*args, **kwargs):
        raise AssertionError("HubSpot static credentials must not use DCR")

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(mcp_api, "register_mcp_oauth_public_client", fail_dcr)

    response = await connect_mcp_oauth_app(
        "hubspot",
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
    )

    assert response.status_code == 303
    query = parse_qs(urlparse(response.headers["location"]).query)
    assert query["client_id"] == ["hubspot-client"]

    server = db.query(MCPServer).filter(MCPServer.name == "hubspot").one()
    assert server.auth["client_id"] == "hubspot-client"
    assert server.auth["token_endpoint_auth_method"] == "client_secret_post"
    assert server.auth["client_secret"] != "hubspot-secret"
    assert decrypt_value(server.auth["client_secret"]) == "hubspot-secret"
    association = (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one()
    )
    response_model = mcp_api._db_server_to_response(
        server,
        association,
        mcp_api.DatabaseMCPServerManager(db),
        is_admin=False,
    )
    assert response_model.config["auth"]["client_secret"] == "********"


@pytest.mark.asyncio
async def test_trusted_connect_app_normalizes_resource_owner(db_session, monkeypatch):
    db, user, _ = db_session
    _add_remote_oauth_catalog_app(db)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    async def register_client(*_args, **_kwargs):
        return SimpleNamespace(
            client_id="dynamic-client-123",
            token_endpoint_auth_method="none",
        )

    monkeypatch.setattr(mcp_api, "register_mcp_oauth_public_client", register_client)

    response = await mcp_api.connect_mcp_oauth_app_for_owner(
        "remote-notes",
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
        resource_owner_key="  toby:slack:workspace:alice  ",
        accept="application/json",
    )

    assert response.status_code == 200
    flow_state = db.query(MCPOAuthFlowState).one()
    assert flow_state.resource_owner_key == "toby:slack:workspace:alice"


@pytest.mark.asyncio
async def test_trusted_connect_rejects_default_resource_owner(db_session):
    db, user, _ = db_session

    with pytest.raises(HTTPException) as exc:
        await mcp_api.connect_mcp_oauth_app_for_owner(
            "remote-notes",
            MCPOAuthConnectRequest(),
            user,
            db,
            resource_owner_key=f"xagent:user:{user.id}",
        )

    assert exc.value.status_code == 400


@pytest.mark.asyncio
async def test_trusted_connect_app_can_roll_back_all_local_state(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _add_remote_oauth_catalog_app(db)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    async def register_client(*_args, **_kwargs):
        return SimpleNamespace(
            client_id="dynamic-client-123",
            token_endpoint_auth_method="none",
        )

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(mcp_api, "register_mcp_oauth_public_client", register_client)

    await mcp_api.connect_mcp_oauth_app_for_owner(
        "remote-notes",
        MCPOAuthConnectRequest(redirect_after="/settings/mcp"),
        user,
        db,
        resource_owner_key="toby:slack:workspace:alice",
        accept="application/json",
    )
    db.rollback()

    assert db.query(MCPServer).filter(MCPServer.name == "remote-notes").count() == 0
    assert db.query(UserMCPServer).filter(UserMCPServer.user_id == user.id).count() == 0
    assert db.query(MCPOAuthClient).count() == 0
    assert db.query(MCPOAuthFlowState).count() == 0


@pytest.mark.asyncio
async def test_connect_app_is_idempotent_across_repeated_connects(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _add_remote_oauth_catalog_app(db)
    monkeypatch.setenv("XAGENT_PUBLIC_API_BASE_URL", "https://api.xagent.test/")

    async def fake_discover(*args, **kwargs):
        return _discovery()

    def registration_handler(request: httpx.Request) -> httpx.Response:
        return httpx.Response(
            201,
            json={
                "client_id": "dynamic-client-123",
                "token_endpoint_auth_method": "none",
            },
        )

    registration_client = httpx.AsyncClient(
        transport=httpx.MockTransport(registration_handler)
    )
    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(
        mcp_oauth_service,
        "create_mcp_oauth_http_client",
        lambda **kwargs: registration_client,
    )

    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )
    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )

    assert db.query(MCPServer).filter(MCPServer.name == "remote-notes").count() == 1
    assert (
        db.query(UserMCPServer)
        .join(MCPServer, UserMCPServer.mcpserver_id == MCPServer.id)
        .filter(MCPServer.name == "remote-notes", UserMCPServer.user_id == user.id)
        .count()
        == 1
    )


@pytest.mark.asyncio
async def test_connect_app_reactivates_a_previously_disconnected_association(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _add_remote_oauth_catalog_app(db)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(
        mcp_oauth_service,
        "create_mcp_oauth_http_client",
        lambda **kwargs: httpx.AsyncClient(
            transport=httpx.MockTransport(
                lambda r: httpx.Response(
                    201,
                    json={
                        "client_id": "dynamic-client-123",
                        "token_endpoint_auth_method": "none",
                    },
                )
            )
        ),
    )

    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )
    server = db.query(MCPServer).filter(MCPServer.name == "remote-notes").one()
    _set_user_mcp_active(db, user, server, False)

    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )

    assoc = (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id, UserMCPServer.mcpserver_id == server.id
        )
        .one()
    )
    assert assoc.is_active is True


@pytest.mark.asyncio
async def test_connect_app_syncs_auth_when_catalog_auth_changes(
    db_session, monkeypatch
):
    """The catalog is the source of truth for the shared row's auth config:
    a registry change (e.g. adding a scope hint) must propagate to the
    already-provisioned server row on the next connect, not persist stale."""
    db, user, _ = db_session
    _add_remote_oauth_catalog_app(db)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(
        mcp_oauth_service,
        "create_mcp_oauth_http_client",
        lambda **kwargs: httpx.AsyncClient(
            transport=httpx.MockTransport(
                lambda r: httpx.Response(
                    201,
                    json={
                        "client_id": "dynamic-client-123",
                        "token_endpoint_auth_method": "none",
                    },
                )
            )
        ),
    )

    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )

    app_row = db.query(PublicMCPApp).filter(PublicMCPApp.app_id == "remote-notes").one()
    app_row.launch_config = {
        "url": "https://mcp.example.com/mcp",
        "auth": {"type": "mcp_oauth", "scope": "meetings.read"},
    }
    db.commit()

    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )

    server = db.query(MCPServer).filter(MCPServer.name == "remote-notes").one()
    assert server.auth == {"type": "mcp_oauth", "scope": "meetings.read"}


@pytest.mark.asyncio
async def test_connect_app_auth_sync_tolerates_a_malformed_sensitive_field(
    db_session, monkeypatch
):
    """F13: encrypt_value() calls .encode() unconditionally, so a mis-authored
    non-string sensitive field (e.g. a nested object where client_secret
    should be a string) must not crash this user-facing connect request —
    it's an admin authoring bug to catch at write time, not here."""
    db, user, _ = db_session
    _add_remote_oauth_catalog_app(db)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(
        mcp_oauth_service,
        "create_mcp_oauth_http_client",
        lambda **kwargs: httpx.AsyncClient(
            transport=httpx.MockTransport(
                lambda r: httpx.Response(
                    201,
                    json={
                        "client_id": "dynamic-client-123",
                        "token_endpoint_auth_method": "none",
                    },
                )
            )
        ),
    )

    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )

    app_row = db.query(PublicMCPApp).filter(PublicMCPApp.app_id == "remote-notes").one()
    app_row.launch_config = {
        "url": "https://mcp.example.com/mcp",
        "auth": {"type": "mcp_oauth", "client_secret": {"nested": "not-a-string"}},
    }
    db.commit()

    # Must not raise — the malformed field is left as-is rather than crashing.
    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )

    server = db.query(MCPServer).filter(MCPServer.name == "remote-notes").one()
    assert server.auth["client_secret"] == {"nested": "not-a-string"}


@pytest.mark.asyncio
async def test_connect_app_does_not_rewrite_unchanged_auth_with_secret(
    db_session, monkeypatch
):
    """Auth drift is detected on the DECRYPTED stored value: sensitive auth
    fields are encrypted at rest, so a raw stored-vs-catalog comparison would
    spuriously differ on every connect and rewrite the row each time. Fernet
    ciphertext changes on re-encryption, so an unchanged ciphertext across
    two connects proves no rewrite happened."""
    db, user, _ = db_session
    db.add(
        PublicMCPApp(
            app_id="remote-notes",
            name="Remote Notes",
            transport="streamable_http",
            launch_config={
                "url": "https://mcp.example.com/mcp",
                "auth": {
                    "type": "mcp_oauth",
                    "client_id": "static-client",
                    "client_secret": "static-secret",
                },
            },
        )
    )
    db.commit()

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )
    server = db.query(MCPServer).filter(MCPServer.name == "remote-notes").one()
    stored_secret_ciphertext = server.auth["client_secret"]
    assert stored_secret_ciphertext != "static-secret"  # encrypted at rest
    assert decrypt_value(stored_secret_ciphertext) == "static-secret"

    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )

    db.refresh(server)
    assert server.auth["client_secret"] == stored_secret_ciphertext


@pytest.mark.asyncio
async def test_connect_app_rejects_non_mcp_oauth_catalog_app(db_session):
    db, user, _ = db_session
    db.add(
        PublicMCPApp(
            app_id="google-maps",
            name="Google Maps",
            transport="stdio",
            launch_config={"command": "npx", "required_env": ["GOOGLE_MAPS_API_KEY"]},
        )
    )
    db.commit()

    with pytest.raises(mcp_api.HTTPException) as exc:
        await connect_mcp_oauth_app(
            "google-maps", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
        )
    assert exc.value.status_code == 400


@pytest.mark.asyncio
async def test_connect_app_rejects_hidden_mcp_oauth_app(db_session):
    """Round-5 m8: the hidden-app gate is wired into this path
    (_ensure_catalog_mcp_oauth_server -> _reject_hidden_catalog_app) but had
    no coverage here — this call site could be deleted and the suite would
    stay green. Mirrors test_connect_rejects_hidden_app in
    test_mcp_apps_connect.py, for the mcp_oauth connect path instead of the
    api_key/keyless one."""
    db, user, _ = db_session
    db.add(
        PublicMCPApp(
            app_id="hidden-remote-notes",
            name="Hidden Remote Notes",
            transport="streamable_http",
            is_visible_in_connector=False,
            launch_config={
                "url": "https://mcp.example.com/mcp",
                "auth": {"type": "mcp_oauth"},
            },
        )
    )
    db.commit()

    with pytest.raises(mcp_api.HTTPException) as exc:
        await connect_mcp_oauth_app(
            "hidden-remote-notes",
            MCPOAuthConnectRequest(redirect_after="/mcp"),
            user,
            db,
        )
    assert exc.value.status_code == 404

    # The gate fired before provisioning: no shared server row was created.
    assert (
        db.query(MCPServer).filter(MCPServer.name == "hidden-remote-notes").first()
        is None
    )


@pytest.mark.asyncio
async def test_connect_app_rejects_unknown_app_id(db_session):
    db, user, _ = db_session

    with pytest.raises(mcp_api.HTTPException) as exc:
        await connect_mcp_oauth_app(
            "no-such-app", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
        )
    assert exc.value.status_code == 404


@pytest.mark.asyncio
async def test_connect_app_rejects_hijacked_server_with_foreign_url(db_session):
    """A pre-existing row under the catalog id with a different remote URL must
    not be reused — otherwise a victim's DCR/PKCE flow talks to an attacker's
    MCP server. Mirrors the stdio hijack guard test in test_mcp_apps_connect.py;
    this shape was previously untested (D1)."""
    db, user, _ = db_session
    _add_remote_oauth_catalog_app(db)
    db.add(
        MCPServer(
            name="remote-notes",
            managed="external",
            transport="streamable_http",
            url="https://evil.example.com/mcp",
        )
    )
    db.commit()

    with pytest.raises(mcp_api.HTTPException) as exc:
        await connect_mcp_oauth_app(
            "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
        )
    assert exc.value.status_code == 409


@pytest.mark.asyncio
async def test_connect_app_rejects_user_owned_server_even_with_matching_config(
    db_session,
):
    """A row under the catalog id that a user OWNS is a custom server squatting
    the id. Even with a config that matches the official launch, it must not be
    adopted as the shared row (D1's guard, previously untested for mcp_oauth)."""
    db, user, other_user = db_session
    _add_remote_oauth_catalog_app(db)
    server = MCPServer(
        name="remote-notes",
        managed="external",
        transport="streamable_http",
        url="https://mcp.example.com/mcp",
        auth={"type": "mcp_oauth"},
    )
    db.add(server)
    db.commit()
    db.add(
        UserMCPServer(
            user_id=other_user.id, mcpserver_id=server.id, is_owner=True, can_edit=True
        )
    )
    db.commit()

    with pytest.raises(mcp_api.HTTPException) as exc:
        await connect_mcp_oauth_app(
            "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
        )
    assert exc.value.status_code == 409


@pytest.mark.asyncio
async def test_connect_app_json_accept_returns_authorization_url_in_body(
    db_session, monkeypatch
):
    """The Accept: application/json branch is what the actual frontend popup
    flow uses; every other test here exercises the 303-redirect branch instead
    (accept=None)."""
    db, user, _ = db_session
    _add_remote_oauth_catalog_app(db)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(
        mcp_oauth_service,
        "create_mcp_oauth_http_client",
        lambda **kwargs: httpx.AsyncClient(
            transport=httpx.MockTransport(
                lambda r: httpx.Response(
                    201,
                    json={
                        "client_id": "dynamic-client-123",
                        "token_endpoint_auth_method": "none",
                    },
                )
            )
        ),
    )

    response = await connect_mcp_oauth_app(
        "remote-notes",
        MCPOAuthConnectRequest(redirect_after="/mcp"),
        user,
        db,
        accept="application/json, text/plain, */*",
    )

    assert response.status_code == 200
    body = json.loads(response.body)
    assert "authorization_url" in body
    query = parse_qs(urlparse(body["authorization_url"]).query)
    assert query["client_id"] == ["dynamic-client-123"]


@pytest.mark.asyncio
async def test_mcp_oauth_app_not_connected_until_grant_completes(
    db_session, monkeypatch
):
    """M1: the UserMCPServer association is created before the user ever
    reaches the consent screen, so it alone must not mean "connected" — an
    abandoned/denied/failed authorization must not render as Connected."""
    db, user, _ = db_session
    _add_remote_oauth_catalog_app(db)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(
        mcp_oauth_service,
        "create_mcp_oauth_http_client",
        lambda **kwargs: httpx.AsyncClient(
            transport=httpx.MockTransport(
                lambda r: httpx.Response(
                    201,
                    json={
                        "client_id": "dynamic-client-123",
                        "token_endpoint_auth_method": "none",
                    },
                )
            )
        ),
    )

    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )
    server = db.query(MCPServer).filter(MCPServer.name == "remote-notes").one()

    apps_before_grant = list_mcp_apps(current_user=user, db=db)
    remote_notes_before = next(
        a for a in apps_before_grant if a["id"] == "remote-notes"
    )
    assert remote_notes_before["is_connected"] is False

    # The DCR flow already registered a client during connect_mcp_oauth_app
    # above; reuse it rather than registering a second one under the same
    # (server, issuer) pair, which would trip the unique lookup_hash.
    client = (
        db.query(MCPOAuthClient).filter(MCPOAuthClient.mcp_server_id == server.id).one()
    )
    db.add(
        MCPOAuthGrant(
            mcp_server_id=server.id,
            user_id=user.id,
            mcp_oauth_client_id=client.id,
            resource_owner_key=f"xagent:user:{user.id}",
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="",
            access_token=encrypt_value("remote-notes-access-token"),
            status="active",
        )
    )
    db.commit()

    apps_after_grant = list_mcp_apps(current_user=user, db=db)
    remote_notes_after = next(a for a in apps_after_grant if a["id"] == "remote-notes")
    assert remote_notes_after["is_connected"] is True
    assert remote_notes_after["server_id"] == server.id


@pytest.mark.asyncio
async def test_mcp_oauth_local_listing_also_requires_a_grant(db_session):
    """F1: the location=local/all branch computed connection state via its
    own name-based membership check and never consulted the active-grant
    gate at all — a custom (non-catalog) mcp_oauth server the user abandoned
    mid-consent rendered as connected there regardless of M1's fix to the
    default/remote branch."""
    db, user, _ = db_session
    # _add_mcp_oauth_server creates a server named "records" with no matching
    # catalog PublicMCPApp, so it falls into the local/all branch rather than
    # being excluded as a known catalog app.
    server = _add_mcp_oauth_server(db, user)

    local_apps_before_grant = list_mcp_apps(location="local", current_user=user, db=db)
    records_before = next(a for a in local_apps_before_grant if a["id"] == "records")
    assert records_before["is_connected"] is False

    client = _add_oauth_client(db, server)
    db.add(
        MCPOAuthGrant(
            mcp_server_id=server.id,
            user_id=user.id,
            mcp_oauth_client_id=client.id,
            resource_owner_key=f"xagent:user:{user.id}",
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="",
            access_token=encrypt_value("records-access-token"),
            status="active",
        )
    )
    db.commit()

    local_apps_after_grant = list_mcp_apps(location="local", current_user=user, db=db)
    records_after = next(a for a in local_apps_after_grant if a["id"] == "records")
    assert records_after["is_connected"] is True


@pytest.mark.asyncio
async def test_local_mcp_oauth_listing_carries_the_auth_type_for_the_picker(
    db_session,
):
    """#1313: the connector picker dispatches Connect on auth_type, which the
    location=local branch never emitted — so a custom mcp_oauth server left
    unconnected by the grant gate above had no branch to fall into and
    dead-ended on the mis-authored-entry toast."""
    db, user, _ = db_session
    _add_mcp_oauth_server(db, user)

    records = next(
        a
        for a in list_mcp_apps(location="local", current_user=user, db=db)
        if a["id"] == "records"
    )
    assert records["is_connected"] is False
    assert records["auth_type"] == "mcp_oauth"


@pytest.mark.asyncio
async def test_local_non_mcp_oauth_server_carries_no_auth_type(db_session):
    """The hint is scoped to the mcp_oauth shape on purpose: a catalog
    classification on any other custom server would repoint the settings
    dialog's Configure button away from the custom edit form."""
    db, user, _ = db_session
    server = MCPServer.from_config(
        {
            "name": "local-notes",
            "managed": "external",
            "transport": "stdio",
            "command": "notes-mcp",
        }
    )
    db.add(server)
    db.commit()
    db.refresh(server)
    db.add(
        UserMCPServer(
            user_id=user.id, mcpserver_id=server.id, is_owner=True, is_active=True
        )
    )
    db.commit()

    notes = next(
        a
        for a in list_mcp_apps(location="local", current_user=user, db=db)
        if a["id"] == "local-notes"
    )
    assert notes["is_connected"] is True
    assert "auth_type" not in notes


@pytest.mark.asyncio
async def test_local_mcp_oauth_listing_omits_auth_type_when_deactivated(db_session):
    """The per-server OAuth endpoints require an active association, so
    advertising the flow on a deactivated server would swap one dead end for
    a 404 — such a server needs re-enabling, not re-authorization."""
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    assoc = (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one()
    )
    assoc.is_active = False
    db.commit()

    records = next(
        a
        for a in list_mcp_apps(location="local", current_user=user, db=db)
        if a["id"] == "records"
    )
    assert "auth_type" not in records


@pytest.mark.asyncio
@pytest.mark.parametrize("actor_state", ["grant", "flow"])
async def test_delete_mcp_server_rejects_actor_owned_oauth_state(
    db_session, actor_state
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    default_owner = mcp_api._default_resource_owner_key(user.id)
    actor_owner = "toby:slack:workspace:alice"
    state_rows: list[MCPOAuthGrant | MCPOAuthFlowState] = [
        MCPOAuthGrant(
            mcp_server_id=server.id,
            user_id=user.id,
            mcp_oauth_client_id=client.id,
            resource_owner_key=default_owner,
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="records.read",
            access_token=encrypt_value("default-access-token"),
        )
    ]
    if actor_state == "grant":
        state_rows.append(
            MCPOAuthGrant(
                mcp_server_id=server.id,
                user_id=user.id,
                mcp_oauth_client_id=client.id,
                resource_owner_key=actor_owner,
                issuer="https://auth.example.com",
                resource="https://mcp.example.com/mcp",
                scope="records.read",
                access_token=encrypt_value("actor-access-token"),
            )
        )
    else:
        state_rows.append(
            MCPOAuthFlowState(
                state="actor-flow",
                mcp_server_id=server.id,
                user_id=user.id,
                mcp_oauth_client_id=client.id,
                resource_owner_key=actor_owner,
                issuer="https://auth.example.com",
                resource="https://mcp.example.com/mcp",
                scope="records.read",
                code_verifier=encrypt_value("verifier"),
                expires_at=mcp_api._utc_now() + timedelta(minutes=10),
            )
        )
    db.add_all(state_rows)
    db.commit()

    with pytest.raises(HTTPException) as exc:
        await delete_mcp_server(server.id, current_user=user, db=db)

    assert exc.value.status_code == 409
    assert db.query(MCPOAuthGrant).count() == (2 if actor_state == "grant" else 1)
    assert db.query(MCPOAuthFlowState).count() == (1 if actor_state == "flow" else 0)
    assert (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one_or_none()
        is not None
    )


@pytest.mark.asyncio
async def test_delete_mcp_server_ignores_terminal_actor_oauth_state(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    actor_owner = "toby:slack:workspace:alice"
    db.add_all(
        [
            MCPOAuthGrant(
                mcp_server_id=server.id,
                user_id=user.id,
                mcp_oauth_client_id=client.id,
                resource_owner_key=actor_owner,
                issuer="https://auth.example.com",
                resource="https://mcp.example.com/mcp",
                scope="records.read",
                access_token=encrypt_value("actor-access-token"),
                status="revoked",
            ),
            MCPOAuthFlowState(
                state="expired-actor-flow",
                mcp_server_id=server.id,
                user_id=user.id,
                mcp_oauth_client_id=client.id,
                resource_owner_key=actor_owner,
                issuer="https://auth.example.com",
                resource="https://mcp.example.com/mcp",
                scope="records.read",
                code_verifier=encrypt_value("verifier"),
                expires_at=mcp_api._utc_now() - timedelta(minutes=1),
            ),
        ]
    )
    db.commit()
    server_id = int(server.id)

    await delete_mcp_server(server_id, current_user=user, db=db)

    assert (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server_id,
        )
        .one_or_none()
        is None
    )


@pytest.mark.asyncio
async def test_delete_mcp_server_revokes_only_the_disconnecting_users_grant(
    db_session, monkeypatch
):
    """M3: disconnecting a shared mcp_oauth catalog server must revoke the
    disconnecting user's own grant immediately, not merely wait for the row to
    cascade away once the last associated user disconnects — and must leave a
    still-connected sibling user's grant untouched."""
    db, user, other_user = db_session
    _add_remote_oauth_catalog_app(db)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)
    monkeypatch.setattr(
        mcp_oauth_service,
        "create_mcp_oauth_http_client",
        lambda **kwargs: httpx.AsyncClient(
            transport=httpx.MockTransport(
                lambda r: httpx.Response(
                    201,
                    json={
                        "client_id": "dynamic-client-123",
                        "token_endpoint_auth_method": "none",
                    },
                )
            )
        ),
    )

    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), user, db
    )
    await connect_mcp_oauth_app(
        "remote-notes", MCPOAuthConnectRequest(redirect_after="/mcp"), other_user, db
    )
    server = db.query(MCPServer).filter(MCPServer.name == "remote-notes").one()
    # Both connects register against the same (server, issuer) pair, so DCR
    # reuses a single client row (see register_mcp_oauth_public_client).
    client = (
        db.query(MCPOAuthClient).filter(MCPOAuthClient.mcp_server_id == server.id).one()
    )

    own_grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="",
        access_token=encrypt_value("own-access-token"),
        status="active",
    )
    sibling_grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=other_user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{other_user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="",
        access_token=encrypt_value("sibling-access-token"),
        status="active",
    )
    db.add_all([own_grant, sibling_grant])
    db.commit()
    db.refresh(own_grant)
    db.refresh(sibling_grant)

    own_grant_id = own_grant.id
    await delete_mcp_server(server.id, current_user=user, db=db)

    # F10: a disconnected grant must not just flip to "revoked" and linger —
    # the row itself (still holding the encrypted access token) is purged.
    assert (
        db.query(MCPOAuthGrant).filter(MCPOAuthGrant.id == own_grant_id).one_or_none()
        is None
    )
    db.refresh(sibling_grant)
    assert sibling_grant.status == "active"

    # The shared row survives (other_user is still associated); only the
    # disconnecting user's association and grant are gone.
    assert (
        db.query(MCPServer).filter(MCPServer.id == server.id).one_or_none() is not None
    )
    assert (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id, UserMCPServer.mcpserver_id == server.id
        )
        .one_or_none()
        is None
    )


@pytest.mark.asyncio
async def test_callback_exchanges_code_and_stores_encrypted_grant(
    db_session, monkeypatch
):
    monkeypatch.setenv("XAGENT_APP_BASE_URL", "https://app.example.com/")
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(
        db,
        server,
        client_secret=mcp_api.encrypt_value("client-secret"),
        token_endpoint_auth_method="client_secret_post",
    )
    association_generation = (
        db.query(UserMCPServer.lifecycle_generation)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .scalar()
    )
    flow_state = MCPOAuthFlowState(
        state="state-123",
        mcp_server_id=server.id,
        user_id=user.id,
        association_lifecycle_generation=association_generation,
        mcp_oauth_client_id=client.id,
        resource_owner_key="resource-owner-a",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        code_verifier=mcp_api.encrypt_value("verifier-123"),
        redirect_after="/mcp",
        expires_at=mcp_api._utc_now() + timedelta(minutes=10),
    )
    db.add(flow_state)
    db.commit()

    real_async_client = httpx.AsyncClient

    def handler(request: httpx.Request) -> httpx.Response:
        form = dict(item.split("=") for item in request.content.decode().split("&"))
        assert form["grant_type"] == "authorization_code"
        assert form["code"] == "auth-code"
        assert form["code_verifier"] == "verifier-123"
        assert form["resource"] == "https%3A%2F%2Fmcp.example.com%2Fmcp"
        assert form["client_secret"] == "client-secret"
        return httpx.Response(
            200,
            json={
                "access_token": "plain-access-token",
                "refresh_token": "plain-refresh-token",
                "token_type": "Bearer",
                "expires_in": 3600,
                "scope": "records.read",
            },
        )

    def async_client_factory(*args, **kwargs):
        return real_async_client(transport=httpx.MockTransport(handler))

    monkeypatch.setattr(mcp_api, "create_mcp_oauth_http_client", async_client_factory)

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=state-123"),
        db,
    )

    assert response.status_code == 307
    # mcp_oauth_success=1 is the explicit positive signal the connect popup's
    # self-close effect keys on (N5) instead of inferring success from the
    # absence of error params.
    assert (
        response.headers["location"]
        == "https://app.example.com/mcp?mcp_oauth_success=1"
    )
    grant = db.query(MCPOAuthGrant).one()
    assert grant.resource_owner_key == "resource-owner-a"
    assert grant.access_token != "plain-access-token"
    assert decrypt_value(grant.access_token) == "plain-access-token"
    assert decrypt_value(grant.refresh_token) == "plain-refresh-token"
    assert db.query(MCPOAuthFlowState).one().consumed_at is not None


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("callback_query", "lose_claim", "expected_error"),
    [
        ("code=auth-code", True, "state_already_consumed"),
        ("error=access_denied", False, "provider_error"),
        ("", False, "invalid_state"),
    ],
    ids=("claim-lost", "provider-error", "missing-code"),
)
async def test_callback_uses_cached_redirect_when_real_delete_removes_claimed_flow(
    db_session,
    monkeypatch,
    callback_query,
    lose_claim,
    expected_error,
):
    db, user, _ = db_session
    server, _, flow = _add_callback_client_and_state(
        db,
        user,
        state=f"deleted-after-claim-{expected_error}",
        redirect_after="/mcp/cached",
    )
    server_id = int(server.id)
    user_id = int(user.id)
    flow_id = int(flow.id)
    state_value = str(flow.state)
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    _allow_standalone_connector_delete(monkeypatch)
    original_claim = mcp_api._claim_mcp_oauth_flow_state

    def claim_then_delete(claim_db, claim_flow):
        if lose_claim:
            with SessionLocal() as competing_claim_db:
                competing_claim_db.query(MCPOAuthFlowState).filter(
                    MCPOAuthFlowState.id == flow_id
                ).update(
                    {MCPOAuthFlowState.consumed_at: mcp_api._utc_now()},
                    synchronize_session=False,
                )
                competing_claim_db.commit()

        claim_result = original_claim(claim_db, claim_flow)
        delete_errors: list[BaseException] = []

        def delete() -> None:
            try:
                with SessionLocal() as delete_db:
                    asyncio.run(
                        delete_mcp_server(
                            server_id,
                            current_user=delete_db.get(User, user_id),
                            db=delete_db,
                        )
                    )
            except BaseException as exc:  # pragma: no cover - assertion reports it
                delete_errors.append(exc)

        delete_thread = threading.Thread(target=delete)
        delete_thread.start()
        delete_thread.join(timeout=DB_PROGRESS_TIMEOUT)
        assert not delete_thread.is_alive()
        assert delete_errors == []
        return claim_result

    monkeypatch.setattr(mcp_api, "_claim_mcp_oauth_flow_state", claim_then_delete)
    separator = "&" if callback_query else ""
    response = await mcp_oauth_callback(
        _request(
            f"/api/mcp/oauth/callback?{callback_query}{separator}state={state_value}"
        ),
        db,
    )

    assert response.status_code == 307
    assert _redirect_query(response)["mcp_oauth_error"] == [expected_error]
    assert urlparse(response.headers["location"]).path == "/mcp/cached"
    db.expire_all()
    assert db.query(MCPOAuthFlowState).count() == 0
    assert db.query(MCPServer).filter(MCPServer.id == server_id).count() == 0


@pytest.mark.asyncio
async def test_callback_rejects_preserved_flow_after_association_generation_changes(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server, _, original_flow = _add_callback_client_and_state(
        db,
        user,
        state="preserved-flow-replaced-association",
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    server_id = int(server.id)
    user_id = int(user.id)
    original_flow_id = int(original_flow.id)
    original_generation = original_flow.association_lifecycle_generation
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)

    async def replace_association_only(**kwargs):
        with SessionLocal() as replacement_db:
            replacement_db.query(UserMCPServer).filter(
                UserMCPServer.user_id == user_id,
                UserMCPServer.mcpserver_id == server_id,
            ).delete(synchronize_session=False)
            replacement = UserMCPServer(
                user_id=user_id,
                mcpserver_id=server_id,
                is_owner=False,
                is_active=True,
            )
            replacement_db.add(replacement)
            replacement_db.commit()
            assert replacement.lifecycle_generation != original_generation
        return {
            "access_token": "issued-access-token",
            "token_type": "Bearer",
            "scope": "records.read",
        }

    revoked: list[mcp_api._MCPOAuthIssuedTokenSnapshot] = []

    async def record_revoke(snapshot):
        revoked.append(snapshot)

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", replace_association_only)
    monkeypatch.setattr(
        mcp_api, "_revoke_mcp_oauth_issued_token_externally", record_revoke
    )

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?code=auth-code&state="
            "preserved-flow-replaced-association"
        ),
        db,
    )

    assert _redirect_query(response)["mcp_oauth_error"] == ["invalid_state"]
    assert len(revoked) == 1
    db.expire_all()
    assert db.query(MCPOAuthGrant).count() == 0
    assert db.query(MCPOAuthFlowState).one().id == original_flow_id
    assert _association_generation(db, user, server) != original_generation


@pytest.mark.asyncio
async def test_callback_rejects_same_flow_id_when_its_generation_changes(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server, _, original_flow = _add_callback_client_and_state(
        db,
        user,
        state="same-flow-id-new-generation",
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    flow_id = int(original_flow.id)
    original_generation = original_flow.association_lifecycle_generation
    changed_generation = uuid4()
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)

    async def change_flow_generation_only(**kwargs):
        with SessionLocal() as replacement_db:
            replacement_db.query(MCPOAuthFlowState).filter(
                MCPOAuthFlowState.id == flow_id
            ).update(
                {
                    MCPOAuthFlowState.association_lifecycle_generation: (
                        changed_generation
                    )
                },
                synchronize_session=False,
            )
            replacement_db.commit()
        return {
            "access_token": "issued-access-token",
            "token_type": "Bearer",
            "scope": "records.read",
        }

    revoked: list[mcp_api._MCPOAuthIssuedTokenSnapshot] = []

    async def record_revoke(snapshot):
        revoked.append(snapshot)

    monkeypatch.setattr(
        mcp_api, "_exchange_mcp_oauth_code", change_flow_generation_only
    )
    monkeypatch.setattr(
        mcp_api, "_revoke_mcp_oauth_issued_token_externally", record_revoke
    )

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?code=auth-code&state=same-flow-id-new-generation"
        ),
        db,
    )

    assert _redirect_query(response)["mcp_oauth_error"] == ["invalid_state"]
    assert len(revoked) == 1
    db.expire_all()
    assert db.query(MCPOAuthGrant).count() == 0
    persisted_flow = db.query(MCPOAuthFlowState).one()
    assert persisted_flow.id == flow_id
    assert persisted_flow.association_lifecycle_generation == changed_generation
    assert persisted_flow.association_lifecycle_generation != original_generation
    assert _association_generation(db, user, server) == original_generation


@pytest.mark.asyncio
async def test_callback_rejects_replacement_lifecycle_and_flow_after_token_issue(
    db_session, monkeypatch
):
    db, user, other_user = db_session
    server, client, original_flow = _add_callback_client_and_state(
        db,
        user,
        state="replacement-lifecycle-state",
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    db.add(
        UserMCPServer(
            user_id=other_user.id,
            mcpserver_id=server.id,
            is_owner=False,
            is_active=True,
        )
    )
    db.commit()
    server_id = int(server.id)
    user_id = int(user.id)
    client_id = int(client.id)
    original_generation = original_flow.association_lifecycle_generation
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    replacement: dict[str, object] = {}

    async def replace_lifecycle_during_exchange(**kwargs):
        other_db = SessionLocal()
        try:
            other_db.query(MCPOAuthFlowState).filter(
                MCPOAuthFlowState.id == original_flow.id
            ).delete(synchronize_session=False)
            other_db.query(UserMCPServer).filter(
                UserMCPServer.user_id == user_id,
                UserMCPServer.mcpserver_id == server_id,
            ).delete(synchronize_session=False)
            other_db.commit()
            replacement_association = UserMCPServer(
                user_id=user_id,
                mcpserver_id=server_id,
                is_owner=False,
                is_active=True,
            )
            other_db.add(replacement_association)
            other_db.flush()
            replacement_flow = MCPOAuthFlowState(
                state="replacement-lifecycle-state",
                mcp_server_id=server_id,
                user_id=user_id,
                association_lifecycle_generation=(
                    replacement_association.lifecycle_generation
                ),
                mcp_oauth_client_id=client_id,
                resource_owner_key="replacement-owner",
                issuer="https://auth.example.com",
                resource="https://mcp.example.com/mcp",
                scope="records.read",
                code_verifier=encrypt_value("replacement-verifier"),
                redirect_after="/replacement",
                expires_at=mcp_api._utc_now() + timedelta(minutes=10),
            )
            other_db.add(replacement_flow)
            other_db.commit()
            replacement["generation"] = replacement_association.lifecycle_generation
            replacement["flow_id"] = replacement_flow.id
        finally:
            other_db.close()
        return {
            "access_token": "issued-access-token",
            "refresh_token": "issued-refresh-token",
            "token_type": "Bearer",
            "scope": "records.read",
        }

    revoked: list[mcp_api._MCPOAuthIssuedTokenSnapshot] = []

    async def record_revoke(snapshot):
        revoked.append(snapshot)

    monkeypatch.setattr(
        mcp_api, "_exchange_mcp_oauth_code", replace_lifecycle_during_exchange
    )
    monkeypatch.setattr(
        mcp_api, "_revoke_mcp_oauth_issued_token_externally", record_revoke
    )

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?code=auth-code&state=replacement-lifecycle-state"
        ),
        db,
    )

    assert _redirect_query(response)["mcp_oauth_error"] == ["invalid_state"]
    assert replacement["generation"] != original_generation
    assert len(revoked) == 1
    assert revoked[0].access_token == "issued-access-token"
    db.expire_all()
    assert db.query(MCPOAuthGrant).count() == 0
    replacement_flow = db.query(MCPOAuthFlowState).one()
    assert replacement_flow.id == replacement["flow_id"]
    assert replacement_flow.redirect_after == "/replacement"


@pytest.mark.asyncio
async def test_callback_rejects_replacement_flow_in_same_lifecycle(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server, client, original_flow = _add_callback_client_and_state(
        db,
        user,
        state="replacement-flow-state",
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    sentinel = MCPOAuthFlowState(
        state="replacement-flow-sentinel",
        mcp_server_id=server.id,
        user_id=user.id,
        association_lifecycle_generation=original_flow.association_lifecycle_generation,
        mcp_oauth_client_id=client.id,
        resource_owner_key="sentinel-owner",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        code_verifier=encrypt_value("sentinel-verifier"),
        expires_at=mcp_api._utc_now() + timedelta(minutes=10),
    )
    db.add(sentinel)
    db.commit()
    original_flow_id = int(original_flow.id)
    server_id = int(server.id)
    user_id = int(user.id)
    client_id = int(client.id)
    lifecycle_generation = original_flow.association_lifecycle_generation
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    replacement_flow_id: list[int] = []

    async def replace_flow_during_exchange(**kwargs):
        other_db = SessionLocal()
        try:
            other_db.query(MCPOAuthFlowState).filter(
                MCPOAuthFlowState.id == original_flow_id
            ).delete(synchronize_session=False)
            other_db.commit()
            replacement_flow = MCPOAuthFlowState(
                state="replacement-flow-state",
                mcp_server_id=server_id,
                user_id=user_id,
                association_lifecycle_generation=lifecycle_generation,
                mcp_oauth_client_id=client_id,
                resource_owner_key="replacement-owner",
                issuer="https://auth.example.com",
                resource="https://mcp.example.com/mcp",
                scope="records.read",
                code_verifier=encrypt_value("replacement-verifier"),
                redirect_after="/replacement",
                expires_at=mcp_api._utc_now() + timedelta(minutes=10),
            )
            other_db.add(replacement_flow)
            other_db.commit()
            replacement_flow_id.append(int(replacement_flow.id))
        finally:
            other_db.close()
        return {
            "access_token": "issued-access-token",
            "token_type": "Bearer",
            "scope": "records.read",
        }

    revoked: list[mcp_api._MCPOAuthIssuedTokenSnapshot] = []

    async def record_revoke(snapshot):
        revoked.append(snapshot)

    monkeypatch.setattr(
        mcp_api, "_exchange_mcp_oauth_code", replace_flow_during_exchange
    )
    monkeypatch.setattr(
        mcp_api, "_revoke_mcp_oauth_issued_token_externally", record_revoke
    )

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=replacement-flow-state"),
        db,
    )

    assert _redirect_query(response)["mcp_oauth_error"] == ["invalid_state"]
    assert replacement_flow_id[0] != original_flow_id
    assert len(revoked) == 1
    db.expire_all()
    assert db.query(MCPOAuthGrant).count() == 0
    replacement_flow = (
        db.query(MCPOAuthFlowState)
        .filter(MCPOAuthFlowState.state == "replacement-flow-state")
        .one()
    )
    assert replacement_flow.id == replacement_flow_id[0]
    assert replacement_flow.consumed_at is None


@pytest.mark.asyncio
async def test_callback_rolls_back_before_revoke_and_sanitizes_failure_log(
    db_session, monkeypatch, caplog
):
    db, user, _ = db_session
    _add_callback_client_and_state(
        db,
        user,
        state="persistence-failure-state",
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    ordering: list[str] = []

    @event.listens_for(db, "after_rollback")
    def record_rollback(session):
        ordering.append("rollback")

    async def fake_exchange(**kwargs):
        return {
            "access_token": "issued-secret-access-token",
            "refresh_token": "issued-secret-refresh-token",
            "token_type": "Bearer",
            "scope": "records.read",
        }

    def fail_persistence(*args, **kwargs):
        raise RuntimeError("raw persistence detail issued-secret-access-token")

    async def record_revoke(snapshot):
        assert not db.in_transaction()
        ordering.append("revoke")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fake_exchange)
    monkeypatch.setattr(mcp_api, "_upsert_mcp_oauth_grant", fail_persistence)
    monkeypatch.setattr(
        mcp_api, "_revoke_mcp_oauth_issued_token_externally", record_revoke
    )

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?code=auth-code&state=persistence-failure-state"
        ),
        db,
    )

    assert _redirect_query(response)["mcp_oauth_error"] == ["token_exchange_failed"]
    assert ordering[-2:] == ["rollback", "revoke"]
    assert "issued-secret-access-token" not in caplog.text
    assert "issued-secret-refresh-token" not in caplog.text
    assert "raw persistence detail" not in caplog.text
    assert "stage=persist_grant" in caplog.text
    assert "exception_type=RuntimeError" in caplog.text
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_issued_token_compensation_revokes_access_and_refresh(monkeypatch):
    requests: list[dict[str, list[str]]] = []
    real_async_client = httpx.AsyncClient

    def handler(request: httpx.Request) -> httpx.Response:
        requests.append(parse_qs(request.content.decode()))
        return httpx.Response(200)

    def async_client_factory(*args, **kwargs):
        return real_async_client(transport=httpx.MockTransport(handler))

    monkeypatch.setattr(mcp_api, "create_mcp_oauth_http_client", async_client_factory)
    await mcp_api._revoke_mcp_oauth_issued_token_externally(
        mcp_api._MCPOAuthIssuedTokenSnapshot(
            flow_id=7,
            revocation_endpoint="https://auth.example.com/revoke",
            client_id="public-client",
            encrypted_client_secret=None,
            token_endpoint_auth_method="none",
            access_token="issued-access-token",
            refresh_token="issued-refresh-token",
        )
    )

    assert [request["token"] for request in requests] == [
        ["issued-access-token"],
        ["issued-refresh-token"],
    ]
    assert [request["token_type_hint"] for request in requests] == [
        ["access_token"],
        ["refresh_token"],
    ]


@pytest.mark.asyncio
async def test_exchange_code_sanitizes_transport_exception(db_session, monkeypatch):
    db, user, _ = db_session
    _, client, _ = _add_callback_client_and_state(
        db,
        user,
        state="transport-error-state",
    )
    real_async_client = httpx.AsyncClient

    def handler(request: httpx.Request) -> httpx.Response:
        raise httpx.ConnectError("raw transport detail with secret-token")

    def async_client_factory(*args, **kwargs):
        return real_async_client(transport=httpx.MockTransport(handler))

    monkeypatch.setattr(mcp_api, "create_mcp_oauth_http_client", async_client_factory)

    with pytest.raises(HTTPException) as exc:
        await mcp_api._exchange_mcp_oauth_code(
            client=client,
            code="auth-code",
            code_verifier="verifier-123",
            resource="https://mcp.example.com/mcp",
        )

    assert exc.value.detail["code"] == "token_exchange_failed"
    assert exc.value.detail["message"] == "OAuth request failed"
    assert "secret-token" not in str(exc.value.detail)


@pytest.mark.asyncio
async def test_callback_rejects_token_type_that_cannot_fit_persistence(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _add_callback_client_and_state(
        db,
        user,
        state="oversized-token-type-state",
        redirect_after="/tools?tab=mcp",
    )

    async def fake_exchange(**kwargs):
        return {
            "access_token": "plain-access-token",
            "token_type": "Bearer" + "x" * MCP_OAUTH_TOKEN_TYPE_MAX_LENGTH,
            "scope": "records.read",
        }

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fake_exchange)

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?code=auth-code&state=oversized-token-type-state"
        ),
        db,
    )

    assert response.status_code == 307
    assert response.headers["location"].startswith("/tools?tab=mcp&")
    query = _redirect_query(response)
    assert query["mcp_oauth_error"] == ["invalid_resource"]
    assert "token_type" in query["mcp_oauth_error_message"][0]
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_callback_accepts_matching_issuer_when_supported(db_session, monkeypatch):
    db, user, _ = db_session
    _add_callback_client_and_state(
        db,
        user,
        state="issuer-match-state",
        metadata_json={"authorization_response_iss_parameter_supported": True},
    )

    async def fake_exchange(**kwargs):
        return {
            "access_token": "plain-access-token",
            "token_type": "Bearer",
            "scope": "records.read",
        }

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fake_exchange)

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?code=auth-code&state=issuer-match-state"
            "&iss=https%3A%2F%2Fauth.example.com%2F"
        ),
        db,
    )

    assert response.status_code == 307
    assert db.query(MCPOAuthGrant).count() == 1


@pytest.mark.asyncio
async def test_callback_rejects_state_without_browser_session_cookie(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _add_callback_client_and_state(db, user, state="missing-cookie-state")

    async def fail_exchange(**kwargs):
        pytest.fail("token exchange must not run without browser-bound state cookie")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fail_exchange)

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?code=auth-code&state=missing-cookie-state",
            bind_oauth_state_cookie=False,
        ),
        db,
    )

    assert response.status_code == 307
    assert _redirect_query(response)["mcp_oauth_error"] == ["invalid_state"]
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_callback_rejects_legacy_state_without_lifecycle_generation(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _, _, flow_state = _add_callback_client_and_state(
        db, user, state="legacy-unbound-state"
    )
    flow_state.association_lifecycle_generation = None
    db.commit()

    async def fail_exchange(**kwargs):
        pytest.fail("an unbound pre-migration flow must fail before token exchange")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fail_exchange)
    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=legacy-unbound-state"),
        db,
    )

    assert _redirect_query(response)["mcp_oauth_error"] == ["invalid_state"]
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_callback_uses_flow_bound_client_when_same_issuer_has_multiple_clients(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    _add_oauth_client(db, server, client_id="stale-client")
    bound_client = _add_oauth_client(db, server, client_id="bound-client")
    association_generation = (
        db.query(UserMCPServer.lifecycle_generation)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .scalar()
    )
    flow_state = MCPOAuthFlowState(
        state="client-bound-state",
        mcp_server_id=server.id,
        user_id=user.id,
        association_lifecycle_generation=association_generation,
        mcp_oauth_client_id=bound_client.id,
        resource_owner_key="resource-owner-a",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        code_verifier=mcp_api.encrypt_value("verifier-123"),
        redirect_after="/mcp",
        expires_at=mcp_api._utc_now() + timedelta(minutes=10),
    )
    db.add(flow_state)
    db.commit()

    async def fake_exchange(**kwargs):
        assert kwargs["client"].client_id == "bound-client"
        return {
            "access_token": "plain-access-token",
            "token_type": "Bearer",
            "scope": "records.read",
        }

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fake_exchange)

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=client-bound-state"),
        db,
    )

    assert response.status_code == 307
    grant = db.query(MCPOAuthGrant).one()
    assert grant.mcp_oauth_client_id == bound_client.id


@pytest.mark.asyncio
async def test_callback_canonicalizes_scope_before_persisting_grant(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server, client, flow_state = _add_callback_client_and_state(
        db,
        user,
        state="scope-canonical-state",
    )
    flow_state.scope = "records.write records.read records.write"
    db.commit()

    async def fake_exchange(**kwargs):
        return {
            "access_token": "plain-access-token",
            "token_type": "Bearer",
            "scope": "records.write records.read records.write",
        }

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fake_exchange)

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=scope-canonical-state"),
        db,
    )

    assert response.status_code == 307
    grant = db.query(MCPOAuthGrant).one()
    assert grant.mcp_server_id == server.id
    assert grant.mcp_oauth_client_id == client.id
    assert grant.scope == "records.read records.write"


@pytest.mark.asyncio
async def test_callback_rejects_scope_that_cannot_fit_grant_lookup_key(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _server, _client, _flow_state = _add_callback_client_and_state(
        db,
        user,
        state="oversized-scope-state",
        redirect_after="/tools",
    )
    oversized_scope = "scope-" + "x" * MCP_OAUTH_SCOPE_MAX_LENGTH

    async def fake_exchange(**kwargs):
        return {
            "access_token": "plain-access-token",
            "token_type": "Bearer",
            "scope": oversized_scope,
        }

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fake_exchange)

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=oversized-scope-state"),
        db,
    )

    assert response.status_code == 307
    query = _redirect_query(response)
    assert query["mcp_oauth_error"] == ["invalid_scope"]
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_callback_without_expires_in_clears_existing_grant_expiry(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server, client, _ = _add_callback_client_and_state(
        db,
        user,
        state="no-expiry-state",
    )
    existing_grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=mcp_api._default_resource_owner_key(user.id),
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=mcp_api.encrypt_value("old-access-token"),
        expires_at=mcp_api._utc_now() - timedelta(minutes=1),
    )
    db.add(existing_grant)
    db.commit()

    async def fake_exchange(**kwargs):
        return {
            "access_token": "plain-access-token",
            "token_type": "Bearer",
            "scope": "records.read",
        }

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fake_exchange)

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=no-expiry-state"),
        db,
    )

    assert response.status_code == 307
    db.refresh(existing_grant)
    assert decrypt_value(existing_grant.access_token) == "plain-access-token"
    assert existing_grant.expires_at is None


@pytest.mark.asyncio
async def test_callback_rejects_missing_required_issuer_before_token_exchange(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _add_callback_client_and_state(
        db,
        user,
        state="issuer-required-state",
        metadata_json={"authorization_response_iss_parameter_supported": True},
    )

    async def fail_exchange(**kwargs):
        pytest.fail("token exchange must not run when callback issuer is required")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fail_exchange)

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=issuer-required-state"),
        db,
    )

    assert response.status_code == 307
    assert _redirect_query(response)["mcp_oauth_error"] == ["issuer_mismatch"]
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_callback_rejects_mismatched_issuer_before_token_exchange(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _add_callback_client_and_state(
        db,
        user,
        state="issuer-mismatch-state",
        metadata_json={"authorization_response_iss_parameter_supported": False},
    )

    async def fail_exchange(**kwargs):
        pytest.fail("token exchange must not run when callback issuer mismatches")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fail_exchange)

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?code=auth-code&state=issuer-mismatch-state"
            "&iss=https%3A%2F%2Fevil.example.com"
        ),
        db,
    )

    assert response.status_code == 307
    assert _redirect_query(response)["mcp_oauth_error"] == ["issuer_mismatch"]
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_callback_rejects_error_response_mismatched_issuer(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _add_callback_client_and_state(
        db,
        user,
        state="issuer-error-state",
        metadata_json={"authorization_response_iss_parameter_supported": True},
    )

    async def fail_exchange(**kwargs):
        pytest.fail("token exchange must not run for authorization error callbacks")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fail_exchange)

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?error=access_denied&state=issuer-error-state"
            "&iss=https%3A%2F%2Fevil.example.com"
        ),
        db,
    )

    assert response.status_code == 307
    assert _redirect_query(response)["mcp_oauth_error"] == ["issuer_mismatch"]
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_callback_sanitizes_authorization_error_response(db_session, monkeypatch):
    db, user, _ = db_session
    _add_callback_client_and_state(
        db,
        user,
        state="authorization-error-state",
        redirect_after="/tools",
    )

    async def fail_exchange(**kwargs):
        pytest.fail("token exchange must not run for authorization error callbacks")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fail_exchange)
    oversized_error = "access_denied_" + "x" * 1000

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?"
            f"error={oversized_error}&state=authorization-error-state"
        ),
        db,
    )

    assert response.status_code == 307
    query = _redirect_query(response)
    # A value that is not a short OAuth error code is replaced, never echoed.
    assert query["mcp_oauth_error"] == ["provider_error"]
    assert query["mcp_oauth_provider_error"] == ["unknown_error"]
    assert len(query["mcp_oauth_error_message"][0]) <= 500
    # No part of the provider's value is forwarded, not even a shortened one.
    location = unquote_plus(response.headers["location"])
    assert "access_denied_" not in location
    assert "x" * 10 not in location
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_callback_truncates_a_long_token_exchange_error_message(
    db_session, monkeypatch
):
    """The redirect message is capped at 500 characters and marked as cut; a
    token endpoint error is the path that still carries provider text into
    it."""
    db, user, _ = db_session
    _add_callback_client_and_state(
        db,
        user,
        state="long-token-error-state",
        redirect_after="/mcp",
    )
    real_async_client = httpx.AsyncClient

    def handler(request: httpx.Request) -> httpx.Response:
        return httpx.Response(
            400,
            json={"error": "invalid_grant", "error_description": "x" * 1000},
        )

    monkeypatch.setattr(
        mcp_api,
        "create_mcp_oauth_http_client",
        lambda *args, **kwargs: real_async_client(
            transport=httpx.MockTransport(handler)
        ),
    )

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=long-token-error-state"),
        db,
    )

    assert response.status_code == 307
    assert urlparse(response.headers["location"]).path == "/mcp"
    query = _redirect_query(response)
    assert query["mcp_oauth_error"] == ["token_exchange_failed"]
    message = query["mcp_oauth_error_message"][0]
    assert len(message) == 500
    assert message.endswith("...")
    assert message[:-3] == "x" * (len(message) - 3)
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "extra_query",
    ["", "&error_description=Your+team+admin+has+not+approved+this+app"],
    ids=("without-description", "with-description"),
)
async def test_callback_reports_provider_refusal_as_provider_error(
    db_session, monkeypatch, caplog, extra_query
):
    monkeypatch.setenv("XAGENT_APP_BASE_URL", "https://app.example.com/")
    db, user, _ = db_session
    server, _, _ = _add_callback_client_and_state(
        db,
        user,
        state="provider-refusal-state",
        redirect_after="/api/connector/oauth/complete",
    )

    async def fail_exchange(**kwargs):
        pytest.fail("token exchange must not run for authorization error callbacks")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fail_exchange)

    with caplog.at_level("WARNING", logger=mcp_api.logger.name):
        response = await mcp_oauth_callback(
            _request(
                "/api/mcp/oauth/callback?error=access_denied"
                f"&state=provider-refusal-state{extra_query}"
            ),
            db,
        )

    assert response.status_code == 307
    location = response.headers["location"]
    assert urlparse(location).path == "/api/connector/oauth/complete"
    query = _redirect_query(response)
    assert query["mcp_oauth_error"] == ["provider_error"]
    assert query["mcp_oauth_provider_error"] == ["access_denied"]
    assert query["mcp_oauth_error_message"] == [
        "The provider did not authorize the connection (access_denied)."
    ]
    assert "mcp_oauth_success" not in query
    # The provider's free text is neither forwarded nor logged.
    assert "approved" not in location
    assert "approved" not in caplog.text
    records = [
        record.getMessage()
        for record in caplog.records
        if "MCP OAuth callback did not connect" in record.getMessage()
    ]
    assert records == [
        "MCP OAuth callback did not connect: "
        f"server_id={server.id} reason=provider_error provider_error=access_denied"
    ]
    assert "provider-refusal-state" not in caplog.text
    assert db.query(MCPOAuthGrant).count() == 0
    assert db.query(MCPOAuthFlowState).one().consumed_at is not None


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("raw_error", "expected"),
    [
        ("temporarily_unavailable", "temporarily_unavailable"),
        ("invalid_scope", "invalid_scope"),
        ("access denied", "unknown_error"),
        ("<script>", "unknown_error"),
        ("a" * 65, "unknown_error"),
    ],
)
async def test_callback_forwards_only_code_shaped_provider_errors(
    db_session, monkeypatch, caplog, raw_error, expected
):
    db, user, _ = db_session
    _add_callback_client_and_state(db, user, state="provider-code-state")

    async def fail_exchange(**kwargs):
        pytest.fail("token exchange must not run for authorization error callbacks")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fail_exchange)

    with caplog.at_level("WARNING", logger=mcp_api.logger.name):
        response = await mcp_oauth_callback(
            _request(
                "/api/mcp/oauth/callback?"
                + urlencode({"error": raw_error, "state": "provider-code-state"})
            ),
            db,
        )

    query = _redirect_query(response)
    assert query["mcp_oauth_error"] == ["provider_error"]
    assert query["mcp_oauth_provider_error"] == [expected]
    assert f"provider_error={expected}" in caplog.text
    if expected == "unknown_error":
        assert raw_error not in unquote_plus(response.headers["location"])
        assert raw_error not in caplog.text


@pytest.mark.asyncio
async def test_callback_accepts_absent_issuer_when_not_supported(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _add_callback_client_and_state(
        db,
        user,
        state="issuer-unsupported-state",
        metadata_json={"authorization_response_iss_parameter_supported": False},
    )

    async def fake_exchange(**kwargs):
        return {
            "access_token": "plain-access-token",
            "token_type": "Bearer",
            "scope": "records.read",
        }

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fake_exchange)

    response = await mcp_oauth_callback(
        _request(
            "/api/mcp/oauth/callback?code=auth-code&state=issuer-unsupported-state"
        ),
        db,
    )

    assert response.status_code == 307
    assert db.query(MCPOAuthGrant).count() == 1


@pytest.mark.asyncio
async def test_callback_rejects_state_replay(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    db.add(
        MCPOAuthFlowState(
            state="used-state",
            mcp_server_id=server.id,
            user_id=user.id,
            mcp_oauth_client_id=client.id,
            resource_owner_key="resource-owner-a",
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="records.read",
            code_verifier=mcp_api.encrypt_value("verifier-123"),
            redirect_after="/mcp",
            expires_at=mcp_api._utc_now() + timedelta(minutes=10),
            consumed_at=mcp_api._utc_now(),
        )
    )
    db.commit()

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=used-state"),
        db,
    )

    assert response.status_code == 307
    assert _redirect_query(response)["mcp_oauth_error"] == ["state_already_consumed"]


@pytest.mark.asyncio
async def test_callback_rejects_expired_state(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    db.add(
        MCPOAuthFlowState(
            state="expired-state",
            mcp_server_id=server.id,
            user_id=user.id,
            mcp_oauth_client_id=client.id,
            resource_owner_key="resource-owner-a",
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="records.read",
            code_verifier=mcp_api.encrypt_value("verifier-123"),
            redirect_after="/mcp",
            expires_at=mcp_api._utc_now() - timedelta(minutes=1),
        )
    )
    db.commit()

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=expired-state"),
        db,
    )

    assert response.status_code == 307
    assert _redirect_query(response)["mcp_oauth_error"] == ["expired_state"]


@pytest.mark.asyncio
async def test_callback_rejects_state_after_user_loses_mcp_access(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    db.add(
        MCPOAuthFlowState(
            state="orphaned-access-state",
            mcp_server_id=server.id,
            user_id=user.id,
            mcp_oauth_client_id=client.id,
            resource_owner_key="resource-owner-a",
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="records.read",
            code_verifier=mcp_api.encrypt_value("verifier-123"),
            redirect_after="/tools",
            expires_at=mcp_api._utc_now() + timedelta(minutes=10),
        )
    )
    db.query(UserMCPServer).filter(
        UserMCPServer.user_id == user.id,
        UserMCPServer.mcpserver_id == server.id,
    ).delete()
    db.commit()

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=orphaned-access-state"),
        db,
    )

    assert response.status_code == 307
    assert _redirect_query(response)["mcp_oauth_error"] == ["invalid_state"]
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_callback_rejects_state_after_user_mcp_server_is_deactivated(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server, _, _ = _add_callback_client_and_state(
        db,
        user,
        state="inactive-access-state",
    )
    _set_user_mcp_active(db, user, server, False)

    async def fail_exchange(**kwargs):
        pytest.fail("token exchange must not run for inactive MCP server access")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fail_exchange)

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=inactive-access-state"),
        db,
    )

    assert response.status_code == 307
    assert _redirect_query(response)["mcp_oauth_error"] == ["invalid_state"]
    assert db.query(MCPOAuthGrant).count() == 0


@pytest.mark.asyncio
async def test_callback_reports_token_exchange_failure(db_session, monkeypatch):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    db.add(
        MCPOAuthFlowState(
            state="bad-token-state",
            mcp_server_id=server.id,
            user_id=user.id,
            association_lifecycle_generation=_association_generation(db, user, server),
            mcp_oauth_client_id=client.id,
            resource_owner_key="resource-owner-a",
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="records.read",
            code_verifier=mcp_api.encrypt_value("verifier-123"),
            redirect_after="/mcp",
            expires_at=mcp_api._utc_now() + timedelta(minutes=10),
        )
    )
    db.commit()

    real_async_client = httpx.AsyncClient

    def async_client_factory(*args, **kwargs):
        return real_async_client(
            transport=httpx.MockTransport(
                lambda request: httpx.Response(
                    400,
                    json={
                        "error": "invalid_grant",
                        "error_description": "authorization code is invalid",
                        "access_token": "leaked-access-token",
                        "refresh_token": "leaked-refresh-token",
                    },
                )
            )
        )

    monkeypatch.setattr(mcp_api, "create_mcp_oauth_http_client", async_client_factory)

    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=bad-token-state"),
        db,
    )

    assert response.status_code == 307
    query = _redirect_query(response)
    assert query["mcp_oauth_error"] == ["token_exchange_failed"]
    assert query["mcp_oauth_error_message"] == ["authorization code is invalid"]
    assert "leaked-access-token" not in response.headers["location"]
    assert "leaked-refresh-token" not in response.headers["location"]
    assert db.query(MCPOAuthGrant).count() == 0
    flow_state = db.query(MCPOAuthFlowState).filter_by(state="bad-token-state").one()
    assert flow_state.consumed_at is not None

    async def fail_exchange(**kwargs):
        pytest.fail("terminal failed state must not be exchanged again")

    monkeypatch.setattr(mcp_api, "_exchange_mcp_oauth_code", fail_exchange)
    response = await mcp_oauth_callback(
        _request("/api/mcp/oauth/callback?code=auth-code&state=bad-token-state"),
        db,
    )
    assert response.status_code == 307
    assert _redirect_query(response)["mcp_oauth_error"] == ["state_already_consumed"]


@pytest.mark.asyncio
async def test_status_and_delete_are_scoped_to_default_owner(db_session):
    db, user, other_user = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    own_grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=mcp_api._default_resource_owner_key(user.id),
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=mcp_api.encrypt_value("own-access-token"),
    )
    actor_grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key="toby:slack:workspace:alice",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=mcp_api.encrypt_value("actor-access-token"),
    )
    other_grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=other_user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=mcp_api._default_resource_owner_key(other_user.id),
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=mcp_api.encrypt_value("other-access-token"),
    )
    db.add_all([own_grant, actor_grant, other_grant])
    db.commit()
    db.refresh(own_grant)
    db.refresh(actor_grant)
    db.refresh(other_grant)

    status_response = await get_mcp_oauth_status(server.id, user, db)

    assert isinstance(status_response, MCPOAuthStatusResponse)
    assert [grant.id for grant in status_response.grants] == [own_grant.id]

    for foreign_grant in (actor_grant, other_grant):
        with pytest.raises(mcp_api.HTTPException) as exc:
            await delete_mcp_oauth_grant(server.id, foreign_grant.id, user, db)
        assert exc.value.status_code == 404

    await delete_mcp_oauth_grant(server.id, own_grant.id, user, db)
    db.refresh(own_grant)
    assert own_grant.status == "revoked"
    assert own_grant.revoked_at is not None

    status_response = await get_mcp_oauth_status(server.id, user, db)
    assert status_response.grants == []


@pytest.mark.asyncio
async def test_trusted_revoke_removes_only_exact_resource_owner(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    grants = [
        MCPOAuthGrant(
            mcp_server_id=server.id,
            user_id=user.id,
            mcp_oauth_client_id=client.id,
            resource_owner_key=owner,
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="records.read",
            access_token=encrypt_value(f"{owner}-token"),
        )
        for owner in (
            f"xagent:user:{user.id}",
            "toby:slack:workspace:alice",
            "toby:slack:workspace:bob",
        )
    ]
    db.add_all(grants)
    db.flush()
    flows = [
        MCPOAuthFlowState(
            state=f"pending-{owner.rsplit(':', 1)[-1]}",
            mcp_server_id=server.id,
            user_id=user.id,
            mcp_oauth_client_id=client.id,
            resource_owner_key=owner,
            issuer="https://auth.example.com",
            resource="https://mcp.example.com/mcp",
            scope="records.read",
            code_verifier=encrypt_value("verifier"),
            expires_at=mcp_api._utc_now() + timedelta(minutes=10),
        )
        for owner in (
            "toby:slack:workspace:alice",
            "toby:slack:workspace:bob",
        )
    ]
    flows[0].consumed_at = mcp_api._utc_now()
    db.add_all(flows)
    association = (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one()
    )
    association.is_active = False
    db.commit()

    revocation = await mcp_api.revoke_mcp_oauth_grants_for_owner(
        server.id,
        user,
        db,
        resource_owner_key="  toby:slack:workspace:alice  ",
    )

    assert revocation.grant_count == 1
    db.expire_all()
    assert [grant.status for grant in grants] == ["active", "revoked", "active"]
    assert [row.resource_owner_key for row in db.query(MCPOAuthFlowState).all()] == [
        "toby:slack:workspace:bob"
    ]

    db.rollback()
    db.expire_all()
    assert [grant.status for grant in grants] == ["active", "active", "active"]
    assert [row.resource_owner_key for row in db.query(MCPOAuthFlowState).all()] == [
        "toby:slack:workspace:alice",
        "toby:slack:workspace:bob",
    ]


@pytest.mark.asyncio
@pytest.mark.parametrize("outcome", ["commit", "rollback"])
async def test_trusted_revoke_defers_provider_work(db_session, monkeypatch, outcome):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(
        db,
        server,
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key="toby:slack:workspace:alice",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=encrypt_value("access-token"),
        refresh_token=encrypt_value("refresh-token"),
    )
    db.add(grant)
    db.commit()
    db.refresh(grant)
    revoked_grants: list[int] = []

    async def record_revoke(snapshot):
        revoked_grants.append(snapshot.grant_id)

    monkeypatch.setattr(
        mcp_api, "_revoke_mcp_oauth_grant_snapshot_externally", record_revoke
    )

    revocation = await mcp_api.revoke_mcp_oauth_grants_for_owner(
        server.id,
        user,
        db,
        resource_owner_key="toby:slack:workspace:alice",
    )

    assert revocation.grant_count == 1
    assert revoked_grants == []
    if outcome == "commit":
        db.commit()
        await revocation.revoke_tokens()
        assert revoked_grants == [grant.id]
        return

    db.rollback()
    assert revoked_grants == []
    assert db.get(MCPOAuthGrant, grant.id).status == "active"


@pytest.mark.asyncio
async def test_trusted_revoke_rejects_blank_resource_owner(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)

    with pytest.raises(HTTPException) as exc:
        await mcp_api.revoke_mcp_oauth_grants_for_owner(
            server.id,
            user,
            db,
            resource_owner_key=" \t ",
        )

    assert exc.value.status_code == 400


@pytest.mark.asyncio
async def test_trusted_revoke_rejects_default_resource_owner(db_session):
    db, user, _ = db_session

    with pytest.raises(HTTPException) as exc:
        await mcp_api.revoke_mcp_oauth_grants_for_owner(
            1,
            user,
            db,
            resource_owner_key=f"xagent:user:{user.id}",
        )

    assert exc.value.status_code == 400


@pytest.mark.asyncio
async def test_delete_grant_revokes_external_tokens_when_endpoint_is_advertised(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(
        db,
        server,
        client_secret=encrypt_value("client-secret"),
        token_endpoint_auth_method="client_secret_post",
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=encrypt_value("access-token"),
        refresh_token=encrypt_value("refresh-token"),
    )
    db.add(grant)
    db.commit()
    db.refresh(grant)
    requests: list[dict[str, list[str]]] = []
    real_async_client = httpx.AsyncClient

    def handler(request: httpx.Request) -> httpx.Response:
        requests.append(parse_qs(request.content.decode()))
        return httpx.Response(200)

    def async_client_factory(*args, **kwargs):
        return real_async_client(transport=httpx.MockTransport(handler))

    monkeypatch.setattr(mcp_api, "create_mcp_oauth_http_client", async_client_factory)

    await delete_mcp_oauth_grant(server.id, grant.id, user, db)

    assert [request["token"] for request in requests] == [
        ["access-token"],
        ["refresh-token"],
    ]
    assert [request["token_type_hint"] for request in requests] == [
        ["access_token"],
        ["refresh_token"],
    ]
    assert all(request["client_secret"] == ["client-secret"] for request in requests)
    db.refresh(grant)
    assert grant.status == "revoked"
    assert grant.revoked_at is not None


@pytest.mark.asyncio
async def test_delete_grant_treats_a_runtime_delete_during_revoke_as_done(
    db_session, monkeypatch
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(
        db,
        server,
        client_secret=encrypt_value("client-secret"),
        token_endpoint_auth_method="client_secret_post",
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=encrypt_value("access-token"),
        refresh_token=encrypt_value("refresh-token"),
    )
    db.add(grant)
    db.commit()
    db.refresh(grant)
    grant_id = grant.id
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)

    async def revoke_and_delete(*args, **kwargs):
        with SessionLocal() as other_db:
            other_db.delete(other_db.get(MCPOAuthGrant, grant_id))
            other_db.commit()

    monkeypatch.setattr(
        mcp_api, "_revoke_mcp_oauth_grant_externally", revoke_and_delete
    )

    await delete_mcp_oauth_grant(server.id, grant_id, user, db)

    db.expire_all()
    assert db.get(MCPOAuthGrant, grant_id) is None


def test_upsert_mcp_oauth_grant_locks_and_reinserts_a_deleted_row(
    db_session, monkeypatch
):
    db, user, _ = db_session
    _server, _client, flow_state = _add_callback_client_and_state(
        db, user, state="state-upsert-lock"
    )
    token_data = {
        "access_token": "first-access",
        "refresh_token": "first-refresh",
        "token_type": "Bearer",
        "expires_in": 3600,
        "scope": "records.read",
    }
    grant = mcp_api._upsert_mcp_oauth_grant(
        db, flow_state=flow_state, token_data=token_data
    )
    db.commit()
    grant_id = grant.id
    lookup_hash = grant.lookup_hash
    SessionLocal = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    with SessionLocal() as other_db:
        other_db.delete(other_db.get(MCPOAuthGrant, grant_id))
        other_db.commit()
    db.expire_all()
    assert db.get(MCPOAuthGrant, grant_id) is None

    lock_queries: list[bool] = []
    original_with_for_update = Query.with_for_update

    def record_with_for_update(self, *args, **kwargs):
        lock_queries.append(True)
        return original_with_for_update(self, *args, **kwargs)

    monkeypatch.setattr(Query, "with_for_update", record_with_for_update)

    mcp_api._upsert_mcp_oauth_grant(db, flow_state=flow_state, token_data=token_data)
    db.commit()

    assert lock_queries
    db.expire_all()
    assert db.get(MCPOAuthGrant, grant_id) is not None
    assert (
        db.query(MCPOAuthGrant).filter(MCPOAuthGrant.lookup_hash == lookup_hash).count()
        == 1
    )


def test_upsert_mcp_oauth_grant_drops_marker_keys_from_a_token_payload(db_session):
    db, user, _ = db_session
    _server, _client, flow_state = _add_callback_client_and_state(
        db, user, state="state-upsert-marker"
    )

    grant = mcp_api._upsert_mcp_oauth_grant(
        db,
        flow_state=flow_state,
        token_data={
            "access_token": "access-token",
            "token_type": "Bearer",
            "expires_in": 3600,
            "scope": "records.read",
            "invalid_grant_at": "2020-01-01T00:00:00+00:00",
            "invalid_grant_token_sha256": "deadbeef",
        },
    )
    db.commit()

    assert "invalid_grant_at" not in grant.metadata_json
    assert "invalid_grant_token_sha256" not in grant.metadata_json


@pytest.mark.asyncio
async def test_delete_mcp_server_revokes_external_tokens_when_endpoint_is_advertised(
    db_session, monkeypatch
):
    """M3's remaining half: disconnecting a server must actually reach the
    provider's revocation_endpoint, not just flip local status (which was
    already fixed in an earlier round but never called the external API)."""
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(
        db,
        server,
        client_secret=encrypt_value("client-secret"),
        token_endpoint_auth_method="client_secret_post",
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=encrypt_value("access-token"),
        refresh_token=encrypt_value("refresh-token"),
    )
    db.add(grant)
    db.commit()
    db.refresh(grant)
    grant_id = grant.id
    requests: list[dict[str, list[str]]] = []
    real_async_client = httpx.AsyncClient

    def handler(request: httpx.Request) -> httpx.Response:
        assert not db.in_transaction()
        requests.append(parse_qs(request.content.decode()))
        return httpx.Response(200)

    def async_client_factory(*args, **kwargs):
        return real_async_client(transport=httpx.MockTransport(handler))

    monkeypatch.setattr(mcp_api, "create_mcp_oauth_http_client", async_client_factory)

    await delete_mcp_server(server.id, current_user=user, db=db)

    assert [request["token"] for request in requests] == [
        ["access-token"],
        ["refresh-token"],
    ]
    # Purged outright rather than left as an inert "revoked" row (F10).
    assert (
        db.query(MCPOAuthGrant).filter(MCPOAuthGrant.id == grant_id).one_or_none()
        is None
    )


@pytest.mark.asyncio
async def test_delete_mcp_server_purges_the_users_own_flow_state_rows(db_session):
    """A leftover MCPOAuthFlowState (e.g. an abandoned/expired connect
    attempt) carries a per-user code_verifier secret that nothing else
    sweeps — disconnect must not leave it behind (F10)."""
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(db, server)
    flow_state = MCPOAuthFlowState(
        state="leftover-state",
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        code_verifier=encrypt_value("verifier-123"),
        expires_at=mcp_api._utc_now() + timedelta(minutes=10),
    )
    db.add(flow_state)
    db.commit()
    flow_state_id = flow_state.id

    await delete_mcp_server(server.id, current_user=user, db=db)

    assert (
        db.query(MCPOAuthFlowState)
        .filter(MCPOAuthFlowState.id == flow_state_id)
        .one_or_none()
        is None
    )


@pytest.mark.asyncio
async def test_delete_mcp_server_preserves_inactive_association_semantics(db_session):
    db, user, other_user = db_session
    server = _add_mcp_oauth_server(db, user)
    association = (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one()
    )
    association.is_active = False
    db.add(
        UserMCPServer(
            user_id=other_user.id,
            mcpserver_id=server.id,
            is_owner=False,
            is_active=True,
        )
    )
    db.commit()

    await delete_mcp_server(server.id, current_user=user, db=db)

    assert (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one_or_none()
        is None
    )
    assert (
        db.query(UserMCPServer)
        .filter(
            UserMCPServer.user_id == other_user.id,
            UserMCPServer.mcpserver_id == server.id,
        )
        .one()
        is not None
    )


@pytest.mark.asyncio
async def test_delete_grant_continues_local_revoke_when_token_decryption_fails(
    db_session, monkeypatch, caplog
):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    client = _add_oauth_client(
        db,
        server,
        token_endpoint_auth_method="none",
        metadata_json={"revocation_endpoint": "https://auth.example.com/revoke"},
    )
    grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token="not-encrypted-token",
    )
    db.add(grant)
    db.commit()
    db.refresh(grant)
    real_async_client = httpx.AsyncClient
    real_decrypt_value = mcp_api.decrypt_value

    def fail_target_token_decrypt(value: str) -> str:
        if value == "not-encrypted-token":
            raise ValueError("cannot decrypt raw-sensitive-provider-detail")
        return real_decrypt_value(value)

    def handler(request: httpx.Request) -> httpx.Response:
        pytest.fail("External revocation should be skipped when token decrypt fails")

    def async_client_factory(*args, **kwargs):
        return real_async_client(transport=httpx.MockTransport(handler))

    monkeypatch.setattr(mcp_api, "decrypt_value", fail_target_token_decrypt)
    monkeypatch.setattr(mcp_api, "create_mcp_oauth_http_client", async_client_factory)

    await delete_mcp_oauth_grant(server.id, grant.id, user, db)

    db.refresh(grant)
    assert grant.status == "revoked"
    assert grant.revoked_at is not None
    assert "raw-sensitive-provider-detail" not in caplog.text
    assert "stage=decrypt_access_token" in caplog.text
    assert "exception_type=ValueError" in caplog.text


@pytest.mark.asyncio
async def test_status_only_reports_grants_matching_current_oauth_config(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    stale_client = _add_oauth_client(db, server, client_id="stale-client")
    current_client = _add_oauth_client(db, server, client_id="client-123")
    stale_grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=stale_client.id,
        resource_owner_key=mcp_api._default_resource_owner_key(user.id),
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=mcp_api.encrypt_value("stale-access-token"),
    )
    current_grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=current_client.id,
        resource_owner_key=mcp_api._default_resource_owner_key(user.id),
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.write records.read",
        access_token=mcp_api.encrypt_value("current-access-token"),
    )
    db.add_all([stale_grant, current_grant])
    db.commit()
    db.refresh(stale_grant)
    db.refresh(current_grant)

    status_response = await get_mcp_oauth_status(server.id, user, db)

    assert [grant.id for grant in status_response.grants] == [current_grant.id]


@pytest.mark.asyncio
async def test_status_reports_discovered_grant_without_configured_selectors(db_session):
    db, user, _ = db_session
    server = _add_mcp_oauth_server(db, user)
    server.auth = {"type": "mcp_oauth", "scope": "records.read"}
    client = _add_oauth_client(db, server, client_id="dynamically-registered-client")
    grant = MCPOAuthGrant(
        mcp_server_id=server.id,
        user_id=user.id,
        mcp_oauth_client_id=client.id,
        resource_owner_key=f"xagent:user:{user.id}",
        issuer="https://auth.example.com",
        resource="https://mcp.example.com/mcp",
        scope="records.read",
        access_token=mcp_api.encrypt_value("access-token"),
    )
    db.add(grant)
    db.commit()
    db.refresh(grant)

    status_response = await get_mcp_oauth_status(server.id, user, db)

    assert [item.id for item in status_response.grants] == [grant.id]


def _teardown_app(
    db, *, app_id: str, transport: str, provider: str | None = None, **launch
) -> PublicMCPApp:
    app = PublicMCPApp(
        app_id=app_id,
        name=app_id.replace("-", " ").title(),
        transport=transport,
        provider_name=provider,
        launch_config=launch or None,
    )
    db.add(app)
    db.commit()
    return app


def _teardown_association(db, user: User, server: MCPServer) -> UserMCPServer:
    association = UserMCPServer(
        user_id=user.id,
        mcpserver_id=server.id,
        is_owner=True,
        can_delete=True,
        is_active=True,
    )
    db.add(association)
    db.commit()
    return association


@pytest.mark.asyncio
async def test_app_teardown_builtin_uses_exact_catalog_credential(db_session):
    db, user, _ = db_session
    app = _teardown_app(
        db, app_id="calendar", transport="oauth", provider="calendar-provider"
    )
    server = MCPServer.from_config(
        {
            "name": "calendar",
            "managed": "external",
            "transport": "oauth",
            "auth": {"app_id": "calendar", "provider": "calendar-provider"},
        }
    )
    db.add(server)
    db.flush()
    association = _teardown_association(db, user, server)
    db.add_all(
        [
            UserOAuth(
                user_id=user.id,
                provider="calendar-provider",
                access_token=encrypt_value("delete-me"),
            ),
            UserOAuth(
                user_id=user.id,
                provider="unrelated",
                access_token=encrypt_value("keep-me"),
            ),
        ]
    )
    db.commit()

    await mcp_api.teardown_mcp_app_server(
        int(server.id),
        app_id="calendar",
        expected_provider_name="calendar-provider",
        expected_catalog_generation=app.generation,
        expected_association_generation=association.lifecycle_generation,
        current_user=user,
        db=db,
    )

    assert db.get(MCPServer, server.id) is None
    assert {row.provider for row in db.query(UserOAuth).all()} == {"unrelated"}


@pytest.mark.asyncio
async def test_app_teardown_rolls_back_then_commits_once_before_safe_revoke(
    db_session, monkeypatch, caplog
):
    db, user, _ = db_session
    db.connection().exec_driver_sql("PRAGMA foreign_keys=ON")
    db.rollback()
    app = _teardown_app(db, app_id="remote-notes", transport="streamable_http")
    server = _add_mcp_oauth_server(db, user, name="remote-notes")
    server.auth = {**server.auth, "app_id": "remote-notes"}
    association = (
        db.query(UserMCPServer).filter_by(user_id=user.id, mcpserver_id=server.id).one()
    )
    association.can_delete = True
    client = _add_oauth_client(
        db,
        server,
        metadata_json={"revocation_endpoint": "https://auth.example/revoke"},
    )
    for state in ("active", "revoked", "inactive"):
        db.add(
            MCPOAuthGrant(
                mcp_server_id=server.id,
                user_id=user.id,
                mcp_oauth_client_id=client.id,
                resource_owner_key=f"owner-{state}",
                issuer="https://auth.example",
                resource="https://mcp.example",
                scope=state,
                access_token=encrypt_value(f"{state}-secret"),
                status=state,
            )
        )
    db.add(
        MCPOAuthFlowState(
            state="delete-flow",
            mcp_server_id=server.id,
            user_id=user.id,
            association_lifecycle_generation=association.lifecycle_generation,
            mcp_oauth_client_id=client.id,
            resource_owner_key="owner-flow",
            issuer="https://auth.example",
            resource="https://mcp.example",
            scope="notes.read",
            code_verifier=encrypt_value("flow-secret"),
            expires_at=mcp_api._utc_now() + timedelta(minutes=10),
        )
    )
    db.commit()
    ids = int(server.id), int(client.id)
    fail = {"once": True}
    commits: list[None] = []
    revoked_grants: list[int] = []

    @event.listens_for(MCPServer, "before_delete")
    def fail_first_delete(_mapper, _connection, target):
        if target.id == ids[0] and fail.pop("once", False):
            raise RuntimeError("local-secret-detail")

    @event.listens_for(db, "after_commit")
    def record_commit(_session):
        commits.append(None)

    kwargs = dict(
        app_id="remote-notes",
        expected_provider_name=None,
        expected_catalog_generation=app.generation,
        expected_association_generation=association.lifecycle_generation,
        current_user=user,
        db=db,
    )
    try:
        with pytest.raises(HTTPException) as exc:
            await mcp_api.teardown_mcp_app_server(ids[0], **kwargs)
        assert exc.value.status_code == 500
        assert db.get(MCPServer, ids[0]) is not None
        assert db.get(MCPOAuthClient, ids[1]) is not None
        assert db.query(MCPOAuthGrant).count() == 3
        assert db.query(MCPOAuthFlowState).count() == 1

        async def fail_revoke(snapshot):
            assert not db.in_transaction()
            revoked_grants.append(snapshot.grant_id)
            raise RuntimeError("remote-secret-detail")

        monkeypatch.setattr(
            mcp_api, "_revoke_mcp_oauth_grant_snapshot_externally", fail_revoke
        )
        await mcp_api.teardown_mcp_app_server(ids[0], **kwargs)
    finally:
        event.remove(MCPServer, "before_delete", fail_first_delete)
        event.remove(db, "after_commit", record_commit)

    assert len(commits) == 1
    assert db.get(MCPServer, ids[0]) is None
    assert db.get(MCPOAuthClient, ids[1]) is None
    assert db.query(MCPOAuthGrant).count() == 0
    assert db.query(MCPOAuthFlowState).count() == 0
    assert len(revoked_grants) == 1
    assert "local-secret-detail" not in caplog.text
    assert "remote-secret-detail" not in caplog.text


@pytest.mark.parametrize(
    ("retention", "expected_server", "refused"),
    [
        ("plain", False, False),
        ("shared", True, False),
        ("team", True, False),
        ("team-refused", True, True),
        ("platform", True, False),
    ],
)
@pytest.mark.asyncio
async def test_app_teardown_preserves_only_governed_non_oauth_servers(
    db_session, monkeypatch, retention, expected_server, refused
):
    db, user, other_user = db_session
    launch = {"command": "notes", "required_env": ["API_KEY"]}
    app = _teardown_app(db, app_id="local-notes", transport="stdio", **launch)
    server = MCPServer.from_config(
        {
            "name": "local-notes",
            "managed": "external",
            "transport": "stdio",
            "command": "notes",
            "env": {"API_KEY": "platform"} if retention == "platform" else None,
        }
    )
    db.add(server)
    db.flush()
    association = _teardown_association(db, user, server)
    if retention == "shared":
        db.add(
            UserMCPServer(user_id=other_user.id, mcpserver_id=server.id, is_active=True)
        )
        db.commit()
    if retention.startswith("team"):
        monkeypatch.setattr(
            connector_team_scope,
            "delete_team_connector",
            lambda *args, **kwargs: SimpleNamespace(
                blocked_reason=None,
                team_owned=True,
                authorized=not refused,
                delete_definition=False,
            ),
        )

    call = mcp_api.teardown_mcp_app_server(
        int(server.id),
        app_id="local-notes",
        expected_provider_name=None,
        expected_catalog_generation=app.generation,
        expected_association_generation=association.lifecycle_generation,
        current_user=user,
        db=db,
    )
    if refused:
        with pytest.raises(HTTPException) as exc:
            await call
        assert exc.value.status_code == 403
    else:
        await call

    assert (db.get(MCPServer, server.id) is not None) is expected_server
    assert (db.get(UserMCPServer, association.id) is not None) is refused


@pytest.mark.parametrize("replaced", ["catalog", "association", "provider", "server"])
@pytest.mark.asyncio
async def test_app_teardown_rejects_replacement_generation(db_session, replaced):
    db, user, other_user = db_session
    app = _teardown_app(db, app_id="replace-me", transport="streamable_http")
    server = _add_mcp_oauth_server(db, user, name="replace-me")
    association = (
        db.query(UserMCPServer).filter_by(user_id=user.id, mcpserver_id=server.id).one()
    )
    association.can_delete = True
    db.add(UserMCPServer(user_id=other_user.id, mcpserver_id=server.id, is_active=True))
    db.commit()
    catalog_generation = app.generation
    association_generation = association.lifecycle_generation
    if replaced == "catalog":
        db.delete(app)
        db.commit()
        replacement = _teardown_app(
            db, app_id="replace-me", transport="streamable_http"
        )
        assert replacement.generation != catalog_generation
    elif replaced == "association":
        db.delete(association)
        db.commit()
        replacement = _teardown_association(db, user, server)
        assert replacement.lifecycle_generation != association_generation
    elif replaced == "provider":
        app.provider_name = "replacement-provider"
        db.commit()
        replacement = app
    else:
        db.delete(server)
        db.commit()
        replacement = None

    with pytest.raises(HTTPException) as exc:
        await mcp_api.teardown_mcp_app_server(
            int(server.id),
            app_id="replace-me",
            expected_provider_name=None,
            expected_catalog_generation=catalog_generation,
            expected_association_generation=association_generation,
            current_user=user,
            db=db,
        )

    assert exc.value.status_code == (
        404 if replaced in {"association", "server"} else 403
    )
    assert (db.get(MCPServer, server.id) is not None) is (replaced != "server")
    if replacement is not None:
        db.refresh(replacement)


@pytest.mark.parametrize("replaced", ["catalog", "association"])
def test_app_teardown_serializes_later_sqlite_replacement(
    db_session, monkeypatch, replaced
):
    db, user, other_user = db_session
    app = _teardown_app(db, app_id="serialize-me", transport="streamable_http")
    server = _add_mcp_oauth_server(db, user, name="serialize-me")
    association = (
        db.query(UserMCPServer).filter_by(user_id=user.id, mcpserver_id=server.id).one()
    )
    association.can_delete = True
    db.add(UserMCPServer(user_id=other_user.id, mcpserver_id=server.id, is_active=True))
    db.commit()
    ids = int(user.id), int(server.id)
    generations = app.generation, association.lifecycle_generation
    factory = sessionmaker(bind=db.get_bind(), autoflush=False, autocommit=False)
    identity_locked = threading.Event()
    release_teardown = threading.Event()
    mutation_sent = threading.Event()
    mutation_done = threading.Event()
    mutation_thread_id: list[int] = []
    replacement_generation: list[object] = []
    real_owner_check = mcp_api._locked_catalog_app_for_server

    def hold_identity(*args, **kwargs):
        result = real_owner_check(*args, **kwargs)
        identity_locked.set()
        assert release_teardown.wait(timeout=DB_PROGRESS_TIMEOUT)
        return result

    def observe_mutation(_conn, _cursor, statement, _params, _context, _many):
        if (
            mutation_thread_id
            and threading.get_ident() == mutation_thread_id[0]
            and statement.lstrip().startswith("DELETE FROM")
        ):
            mutation_sent.set()

    monkeypatch.setattr(mcp_api, "_locked_catalog_app_for_server", hold_identity)
    event.listen(db.get_bind(), "before_cursor_execute", observe_mutation)

    def teardown():
        with factory() as teardown_db:
            asyncio.run(
                mcp_api.teardown_mcp_app_server(
                    ids[1],
                    app_id="serialize-me",
                    expected_provider_name=None,
                    expected_catalog_generation=generations[0],
                    expected_association_generation=generations[1],
                    current_user=teardown_db.get(User, ids[0]),
                    db=teardown_db,
                )
            )

    def replace():
        mutation_thread_id.append(threading.get_ident())
        with factory() as mutation_db:
            if replaced == "catalog":
                mutation_db.query(PublicMCPApp).filter_by(
                    app_id="serialize-me"
                ).delete()
                replacement = PublicMCPApp(
                    app_id="serialize-me",
                    name="Serialize Me",
                    transport="streamable_http",
                )
            else:
                mutation_db.query(UserMCPServer).filter_by(
                    user_id=ids[0], mcpserver_id=ids[1]
                ).delete()
                replacement = UserMCPServer(
                    user_id=ids[0], mcpserver_id=ids[1], is_active=True
                )
            mutation_db.add(replacement)
            mutation_db.commit()
            replacement_generation.append(
                replacement.generation
                if replaced == "catalog"
                else replacement.lifecycle_generation
            )
        mutation_done.set()

    teardown_thread = threading.Thread(target=teardown)
    mutation_thread = threading.Thread(target=replace)
    try:
        teardown_thread.start()
        assert identity_locked.wait(timeout=DB_PROGRESS_TIMEOUT)
        mutation_thread.start()
        assert mutation_sent.wait(timeout=DB_PROGRESS_TIMEOUT)
        assert not mutation_done.wait(timeout=0.2)
        release_teardown.set()
        teardown_thread.join(timeout=DB_PROGRESS_TIMEOUT)
        mutation_thread.join(timeout=DB_PROGRESS_TIMEOUT)
    finally:
        release_teardown.set()
        event.remove(db.get_bind(), "before_cursor_execute", observe_mutation)

    assert not teardown_thread.is_alive() and not mutation_thread.is_alive()
    expected_index = 0 if replaced == "catalog" else 1
    assert replacement_generation[0] != generations[expected_index]


@pytest.mark.asyncio
async def test_regional_bootstrap_moves_proof_without_changing_flow_client(
    db_session, monkeypatch
):
    import json

    from fastapi import FastAPI

    from xagent.web.oauth_handoff import OAuthHandoffContext, redeem_handoff

    db, user, _ = db_session
    old = "https://xagent.example.com"
    new = "https://new.example.com"
    monkeypatch.setenv("XAGENT_APP_BASE_URL", old)
    monkeypatch.setenv("XAGENT_DUAL_ENTRY_OAUTH_ENABLED", "true")
    monkeypatch.setenv(
        "XAGENT_PUBLIC_ENTRIES_JSON",
        json.dumps(
            [
                {
                    "origin": o,
                    "region_cookie_domain": None,
                    "google_oidc_redirect_uri": o + "/api/auth/oidc/google/callback",
                }
                for o in [old, new]
            ]
        ),
    )
    server = _add_mcp_oauth_server(db, user)

    async def fake_discover(*args, **kwargs):
        return _discovery()

    monkeypatch.setattr(mcp_api, "discover_mcp_oauth_metadata", fake_discover)

    class Adapter:
        def context(self, request):
            return OAuthHandoffContext("xagent", "prod", "au", old)

        def set_route_cookie(self, response, *, state, kind, provider):
            assert kind == "mcp" and provider is None
            response.set_cookie("scoped-mcp", "au")

    app = FastAPI()
    app.state.oauth_handoff_adapter = Adapter()
    req = _request(
        "/api/mcp/1/oauth/connect",
        headers=[
            (b"host", b"new.example.com"),
            (b"x-xagent-oauth-launch-version", b"2"),
        ],
    )
    req.scope["app"] = app
    response = await connect_mcp_oauth(
        server.id,
        MCPOAuthConnectRequest(redirect_after="/tools"),
        user,
        db,
        request=req,
    )
    assert "set-cookie" not in response.headers
    data = json.loads(response.body)
    assert data["launch_mode"] == "regional_bootstrap"
    flow = db.query(MCPOAuthFlowState).one()
    original_client = db.query(MCPOAuthClient).one()
    assert flow.redirect_after == "/auth/mcp-complete"
    assert original_client.redirect_uri == old + "/api/mcp/oauth/callback"
    bootstrap = _request(
        data["authorization_url"], headers=[(b"host", b"xagent.example.com")]
    )
    bootstrap.scope["app"] = app
    # Step one only renders the confirmation page: no proof cookie, no consume.
    page = redeem_handoff("au", bootstrap, db)
    assert page.status_code == 200
    assert not any(
        "mcp_oauth_state" in cookie or "scoped-mcp" in cookie
        for cookie in page.headers.getlist("set-cookie")
    )
    href = html.unescape(re.search(r'href="([^"]+)"', page.body.decode())[1])
    confirm_cookie = page.headers["set-cookie"].split(";", 1)[0]
    bootstrap = _request(
        data["authorization_url"].split("?", 1)[0] + href,
        headers=[
            (b"host", b"xagent.example.com"),
            (b"cookie", confirm_cookie.encode()),
        ],
    )
    bootstrap.scope["app"] = app
    released = redeem_handoff("au", bootstrap, db)
    assert released.status_code == 303
    cookies = released.headers.getlist("set-cookie")
    assert any("Path=/api/mcp" in cookie for cookie in cookies)
    assert any("scoped-mcp" in cookie for cookie in cookies)
    assert not any("selected_region" in cookie for cookie in cookies)
    query = _redirect_query(released)
    assert query["redirect_uri"] == [original_client.redirect_uri]
    assert query["client_id"] == [original_client.client_id]
    assert query["code_challenge"] == [
        mcp_api._pkce_code_challenge(decrypt_value(flow.code_verifier))
    ]
    assert db.query(MCPOAuthClient).count() == 1
    with pytest.raises(HTTPException) as exc:
        redeem_handoff("au", bootstrap, db)
    assert exc.value.status_code == 401