Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Remove admin impersonation feature from MCP (#4889)
Marc Kelechava2f65635e989d
diff --git a/skyvern/cli/core/mcp_http_auth.py b/skyvern/cli/core/mcp_http_auth.pyindex 03d17a04b..85c28dfc5 100644--- a/skyvern/cli/core/mcp_http_auth.py+++ b/skyvern/cli/core/mcp_http_auth.py@@ -4,7 +4,6 @@ import asyncioimport osimport timefrom collections import OrderedDict-from contextvars import ContextVar, Tokenfrom dataclasses import dataclassfrom threading import RLock@@ -24,12 +23,8 @@ from .client import reset_api_key_override, set_api_key_overrideLOG = structlog.get_logger(__name__)API_KEY_HEADER = "x-api-key"-TARGET_ORG_ID_HEADER = "x-target-org-id"HEALTH_PATHS = {"/health", "/healthz"}-_MCP_ALLOWED_TOKEN_TYPES = (- OrganizationAuthTokenType.api,- OrganizationAuthTokenType.mcp_admin_impersonation,-)+_MCP_ALLOWED_TOKEN_TYPES = (OrganizationAuthTokenType.api,)_auth_db: AgentDB | None = None_auth_db_lock = RLock()_api_key_cache_lock = RLock()@@ -39,73 +34,6 @@ _VALIDATION_RETRY_EXHAUSTED_MESSAGE = "API key validation temporarily unavailabl_MAX_VALIDATION_RETRIES = 2_RETRY_DELAY_SECONDS = 0.25-# ----------------------------------------------------------------------------# Impersonation session state-# -----------------------------------------------------------------------------_admin_api_key_hash: ContextVar[str | None] = ContextVar("admin_api_key_hash", default=None)---@dataclass(frozen=True)-class ImpersonationSession:- admin_api_key_hash: str- admin_org_id: str- target_org_id: str- # Stored in plaintext in process memory for up to TTL. Acceptable V1 trade-off- # (in-process only, same as API key cache).- target_api_key: str- expires_at: float # time.monotonic() deadline- ttl_minutes: int---_impersonation_sessions: dict[str, ImpersonationSession] = {}-_impersonation_lock = RLock()--MAX_TTL_MINUTES = 120-DEFAULT_TTL_MINUTES = 30-_MAX_IMPERSONATION_SESSIONS = 100---def get_active_impersonation(admin_key_hash: str) -> ImpersonationSession | None:- with _impersonation_lock:- session = _impersonation_sessions.get(admin_key_hash)- if session is None:- return None- if session.expires_at <= time.monotonic():- _impersonation_sessions.pop(admin_key_hash, None)- return None- return session---def set_impersonation_session(session: ImpersonationSession) -> None:- with _impersonation_lock:- _impersonation_sessions[session.admin_api_key_hash] = session- # Sweep expired sessions, then evict oldest if over capacity- now = time.monotonic()- expired_keys = [k for k, s in _impersonation_sessions.items() if s.expires_at <= now]- for k in expired_keys:- _impersonation_sessions.pop(k, None)- if len(_impersonation_sessions) > _MAX_IMPERSONATION_SESSIONS:- oldest_key = min(_impersonation_sessions, key=lambda k: _impersonation_sessions[k].expires_at)- _impersonation_sessions.pop(oldest_key, None)---def clear_impersonation_session(admin_key_hash: str) -> ImpersonationSession | None:- with _impersonation_lock:- return _impersonation_sessions.pop(admin_key_hash, None)---def clear_all_impersonation_sessions() -> None:- with _impersonation_lock:- _impersonation_sessions.clear()---def get_admin_api_key_hash() -> str | None:- return _admin_api_key_hash.get()---# ----------------------------------------------------------------------------@dataclass(frozen=True)class MCPAPIKeyValidation:@@ -160,7 +88,6 @@ async def close_auth_db() -> None:_auth_db = Nonewith _api_key_cache_lock:_api_key_validation_cache.clear()- clear_all_impersonation_sessions()if db is None:return@@ -174,25 +101,6 @@ def cache_key(api_key: str) -> str:return hash_api_key_for_cache(api_key)-def _admin_organization_ids() -> set[str]:- try:- from cloud.config import settings as cloud_settings # noqa: PLC0415-- admin_ids = getattr(cloud_settings, "ADMIN_ORGANIZATION_IDS", [])- except ImportError:- admin_ids = getattr(settings, "ADMIN_ORGANIZATION_IDS", [])- return {org_id for org_id in admin_ids if org_id}---def _is_admin_impersonation_enabled() -> bool:- try:- from cloud.config import settings as cloud_settings # noqa: PLC0415-- return bool(getattr(cloud_settings, "MCP_ADMIN_IMPERSONATION_ENABLED", False))- except ImportError:- return bool(getattr(settings, "MCP_ADMIN_IMPERSONATION_ENABLED", False))--async def validate_mcp_api_key(api_key: str) -> MCPAPIKeyValidation:"""Validate API key and return caller organization + token type."""key = cache_key(api_key)@@ -267,24 +175,6 @@ def _service_unavailable_response(message: str) -> JSONResponse:)-def _deny_impersonation(- *,- reason: str,- caller_organization_id: str | None,- target_organization_id: str | None,- token_type: OrganizationAuthTokenType | None = None,-) -> JSONResponse:- log_kwargs: dict[str, object] = {- "reason": reason,- "caller_organization_id": caller_organization_id,- "target_organization_id": target_organization_id,- }- if token_type is not None:- log_kwargs["token_type"] = token_type.value- LOG.warning("MCP admin impersonation denied", **log_kwargs)- return _unauthorized_response("Impersonation not allowed")--class MCPAPIKeyMiddleware:"""Require x-api-key for MCP HTTP transport and scope requests to that key."""@@ -312,110 +202,18 @@ class MCPAPIKeyMiddleware:await response(scope, receive, send)return- target_org_id_header = request.headers.get(TARGET_ORG_ID_HEADER)- admin_hash_token: Token[str | None] | None = None-try:validation = await validate_mcp_api_key(api_key)- caller_organization_id = validation.organization_id- admin_key_hash = cache_key(api_key)-scope.setdefault("state", {})- if target_org_id_header is not None:- # Explicit header-based impersonation (takes priority over session)- if not _is_admin_impersonation_enabled():- response = _deny_impersonation(- reason="feature_disabled",- caller_organization_id=caller_organization_id,- target_organization_id=target_org_id_header.strip() or target_org_id_header,- )- await response(scope, receive, send)- return-- target_organization_id = target_org_id_header.strip()- if not target_organization_id:- response = _deny_impersonation(- reason="missing_target_organization_id",- caller_organization_id=caller_organization_id,- target_organization_id=target_org_id_header,- token_type=validation.token_type,- )- await response(scope, receive, send)- return-- # Delegate validation to the single source of truth in cloud/.- # The import can't fail here — _is_admin_impersonation_enabled()- # already returned True, which requires cloud.config to be importable.- try:- from cloud.mcp_admin_tools import validate_impersonation_target # noqa: PLC0415- except ImportError:- response = _deny_impersonation(- reason="impersonation_not_available",- caller_organization_id=caller_organization_id,- target_organization_id=target_organization_id,- )- await response(scope, receive, send)- return-- result = await validate_impersonation_target(- caller_organization_id=caller_organization_id,- target_organization_id=target_organization_id,- token_type=validation.token_type,- )- if isinstance(result, str):- response = _deny_impersonation(- reason=result,- caller_organization_id=caller_organization_id,- target_organization_id=target_organization_id,- token_type=validation.token_type,- )- await response(scope, receive, send)- return-- resolved_org_id, target_api_key = result- api_key = target_api_key-- scope["state"]["organization_id"] = resolved_org_id- scope["state"]["admin_organization_id"] = caller_organization_id- scope["state"]["impersonation_target_organization_id"] = resolved_org_id- admin_hash_token = _admin_api_key_hash.set(admin_key_hash)- LOG.info(- "MCP admin impersonation allowed",- caller_organization_id=caller_organization_id,- target_organization_id=resolved_org_id,- token_type=validation.token_type.value,- )- else:- # No explicit header — check for session-based impersonation- session = get_active_impersonation(admin_key_hash)- if session is not None:- # Session data (target API key) is cached for TTL. If the target org's- # key is revoked mid-session, impersonation continues until expiry —- # acceptable trade-off vs re-validating every request.- api_key = session.target_api_key- scope["state"]["organization_id"] = session.target_org_id- scope["state"]["admin_organization_id"] = session.admin_org_id- scope["state"]["impersonation_target_organization_id"] = session.target_org_id- admin_hash_token = _admin_api_key_hash.set(admin_key_hash)- LOG.info(- "MCP session impersonation applied",- caller_organization_id=session.admin_org_id,- target_organization_id=session.target_org_id,- ttl_minutes=session.ttl_minutes,- )- else:- scope["state"]["organization_id"] = caller_organization_id+ scope["state"]["organization_id"] = validation.organization_idexcept HTTPException as e:if e.status_code in {401, 403}:response = _unauthorized_response("Invalid API key")- await response(scope, receive, send)- return- if e.status_code == 503:+ elif e.status_code == 503:response = _service_unavailable_response(e.detail or _VALIDATION_RETRY_EXHAUSTED_MESSAGE)- await response(scope, receive, send)- return- LOG.warning("Unexpected HTTPException during MCP API key validation", status_code=e.status_code)- response = _internal_error_response()+ else:+ LOG.warning("Unexpected HTTPException during MCP API key validation", status_code=e.status_code)+ response = _internal_error_response()await response(scope, receive, send)returnexcept Exception:@@ -429,5 +227,3 @@ class MCPAPIKeyMiddleware:await self.app(scope, receive, send)finally:reset_api_key_override(token)- if admin_hash_token is not None:- _admin_api_key_hash.reset(admin_hash_token)diff --git a/skyvern/cli/mcp_tools/__init__.py b/skyvern/cli/mcp_tools/__init__.pyindex 24311c677..37ba1cb80 100644--- a/skyvern/cli/mcp_tools/__init__.py+++ b/skyvern/cli/mcp_tools/__init__.py@@ -286,14 +286,6 @@ mcp.tool()(skyvern_workflow_run)mcp.tool()(skyvern_workflow_status)mcp.tool()(skyvern_workflow_cancel)-# -- Admin impersonation (cloud-only, session-level org switching) ---try:- from cloud.mcp_admin_tools import register_admin_tools # noqa: PLC0415-- register_admin_tools(mcp)-except ImportError:- pass-# -- Prompts (methodology guides injected into LLM conversations) --mcp.prompt()(build_workflow)mcp.prompt()(debug_automation)diff --git a/skyvern/forge/sdk/db/enums.py b/skyvern/forge/sdk/db/enums.pyindex b07e32fd7..de2271258 100644--- a/skyvern/forge/sdk/db/enums.py+++ b/skyvern/forge/sdk/db/enums.py@@ -3,7 +3,6 @@ from enum import StrEnumclass OrganizationAuthTokenType(StrEnum):api = "api"- mcp_admin_impersonation = "mcp_admin_impersonation"onepassword_service_account = "onepassword_service_account"azure_client_secret_credential = "azure_client_secret_credential"custom_credential_service = "custom_credential_service"diff --git a/tests/unit/test_mcp_http_auth.py b/tests/unit/test_mcp_http_auth.pyindex 4b38ecc6c..e15edb079 100644--- a/tests/unit/test_mcp_http_auth.py+++ b/tests/unit/test_mcp_http_auth.py@@ -1,7 +1,6 @@from __future__ import annotationsimport asyncio-import timefrom types import SimpleNamespacefrom unittest.mock import AsyncMock@@ -16,7 +15,6 @@ from starlette.routing import Routefrom skyvern.cli.core import client as client_modfrom skyvern.cli.core import mcp_http_auth-from skyvern.forge.sdk.db.enums import OrganizationAuthTokenType@pytest.fixture(autouse=True)@@ -28,7 +26,6 @@ def _reset_auth_context() -> None:mcp_http_auth._API_KEY_CACHE_MAX_SIZE = 1024mcp_http_auth._MAX_VALIDATION_RETRIES = 2mcp_http_auth._RETRY_DELAY_SECONDS = 0.0 # no delay in tests- mcp_http_auth.clear_all_impersonation_sessions()async def _echo_request_context(request: Request) -> JSONResponse:@@ -36,31 +33,25 @@ async def _echo_request_context(request: Request) -> JSONResponse:{"api_key": client_mod.get_active_api_key(),"organization_id": getattr(request.state, "organization_id", None),- "admin_organization_id": getattr(request.state, "admin_organization_id", None),- "impersonation_target_organization_id": getattr(- request.state, "impersonation_target_organization_id", None- ),})def _build_validation(organization_id: str,- token_type: OrganizationAuthTokenType = OrganizationAuthTokenType.api,) -> mcp_http_auth.MCPAPIKeyValidation:return mcp_http_auth.MCPAPIKeyValidation(organization_id=organization_id,- token_type=token_type,+ token_type=mcp_http_auth.OrganizationAuthTokenType.api,)def _build_resolved_validation(organization_id: str,- token_type: OrganizationAuthTokenType = OrganizationAuthTokenType.api,) -> SimpleNamespace:return SimpleNamespace(organization=SimpleNamespace(organization_id=organization_id),- token=SimpleNamespace(token_type=token_type),+ token=SimpleNamespace(token_type=mcp_http_auth.OrganizationAuthTokenType.api),)@@ -176,8 +167,6 @@ async def test_mcp_http_auth_sets_request_scoped_api_key(monkeypatch: pytest.Monassert response.json() == {"api_key": "sk_live_abc","organization_id": "org_123",- "admin_organization_id": None,- "impersonation_target_organization_id": None,}assert client_mod.get_active_api_key() != "sk_live_abc"@@ -331,220 +320,3 @@ async def test_close_auth_db_noop_when_uninitialized() -> None:mcp_http_auth._auth_db = Noneawait mcp_http_auth.close_auth_db()assert mcp_http_auth._auth_db is None---async def test_mcp_http_auth_denies_target_org_when_feature_disabled(monkeypatch: pytest.MonkeyPatch) -> None:- validate_mock = AsyncMock(- return_value=_build_validation(- "org_admin",- OrganizationAuthTokenType.mcp_admin_impersonation,- )- )- monkeypatch.setattr(- mcp_http_auth,- "validate_mcp_api_key",- validate_mock,- )- monkeypatch.setattr(mcp_http_auth, "_is_admin_impersonation_enabled", lambda: False)- app = _build_test_app()-- async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver") as client:- response = await client.post(- "/mcp",- headers={"x-api-key": "sk_live_admin", "x-target-org-id": "org_target"},- json={},- )-- assert response.status_code == 401- assert response.json()["error"]["code"] == "UNAUTHORIZED"- assert response.json()["error"]["message"] == "Impersonation not allowed"- validate_mock.assert_awaited_once_with("sk_live_admin")---async def test_mcp_http_auth_validates_api_key_before_feature_flag_denial(monkeypatch: pytest.MonkeyPatch) -> None:- validate_mock = AsyncMock(side_effect=HTTPException(status_code=403, detail="Invalid credentials"))- monkeypatch.setattr(mcp_http_auth, "validate_mcp_api_key", validate_mock)- monkeypatch.setattr(mcp_http_auth, "_is_admin_impersonation_enabled", lambda: False)- app = _build_test_app()-- async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver") as client:- response = await client.post(- "/mcp",- headers={"x-api-key": "bad-key", "x-target-org-id": "org_target"},- json={},- )-- assert response.status_code == 401- assert response.json()["error"]["code"] == "UNAUTHORIZED"- assert response.json()["error"]["message"] == "Invalid API key"- validate_mock.assert_awaited_once_with("bad-key")--[email protected]("target_org_id", ["", " \t "])-async def test_mcp_http_auth_denies_empty_or_whitespace_target_org_id_header(- monkeypatch: pytest.MonkeyPatch,- target_org_id: str,-) -> None:- validate_mock = AsyncMock(- return_value=_build_validation(- "org_admin",- OrganizationAuthTokenType.mcp_admin_impersonation,- )- )- monkeypatch.setattr(mcp_http_auth, "validate_mcp_api_key", validate_mock)- monkeypatch.setattr(mcp_http_auth, "_is_admin_impersonation_enabled", lambda: True)- app = _build_test_app()-- async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver") as client:- response = await client.post(- "/mcp",- headers={"x-api-key": "sk_live_admin", "x-target-org-id": target_org_id},- json={},- )-- assert response.status_code == 401- assert response.json()["error"]["code"] == "UNAUTHORIZED"- assert response.json()["error"]["message"] == "Impersonation not allowed"- validate_mock.assert_awaited_once_with("sk_live_admin")---# ----------------------------------------------------------------------------# Session-based impersonation tests-# ------------------------------------------------------------------------------def test_impersonation_session_lifecycle() -> None:- """set → get → clear lifecycle."""- admin_hash = mcp_http_auth.cache_key("sk_admin_key")- session = mcp_http_auth.ImpersonationSession(- admin_api_key_hash=admin_hash,- admin_org_id="org_admin",- target_org_id="org_target",- target_api_key="sk_target_key",- expires_at=time.monotonic() + 600,- ttl_minutes=10,- )- mcp_http_auth.set_impersonation_session(session)-- retrieved = mcp_http_auth.get_active_impersonation(admin_hash)- assert retrieved is not None- assert retrieved.target_org_id == "org_target"-- cleared = mcp_http_auth.clear_impersonation_session(admin_hash)- assert cleared is not None- assert cleared.target_org_id == "org_target"-- assert mcp_http_auth.get_active_impersonation(admin_hash) is None---def test_impersonation_session_auto_expiry() -> None:- """Expired sessions are lazily cleaned up on get."""- admin_hash = mcp_http_auth.cache_key("sk_admin_key")- session = mcp_http_auth.ImpersonationSession(- admin_api_key_hash=admin_hash,- admin_org_id="org_admin",- target_org_id="org_target",- target_api_key="sk_target_key",- expires_at=time.monotonic() - 1, # already expired- ttl_minutes=1,- )- mcp_http_auth.set_impersonation_session(session)-- assert mcp_http_auth.get_active_impersonation(admin_hash) is None---async def test_middleware_applies_session_impersonation(monkeypatch: pytest.MonkeyPatch) -> None:- """When a session is active, middleware auto-applies impersonation without header."""- monkeypatch.setattr(- mcp_http_auth,- "validate_mcp_api_key",- AsyncMock(- return_value=_build_validation(- "org_admin",- OrganizationAuthTokenType.mcp_admin_impersonation,- )- ),- )-- admin_hash = mcp_http_auth.cache_key("sk_live_admin")- session = mcp_http_auth.ImpersonationSession(- admin_api_key_hash=admin_hash,- admin_org_id="org_admin",- target_org_id="org_target",- target_api_key="sk_live_target_key",- expires_at=time.monotonic() + 600,- ttl_minutes=10,- )- mcp_http_auth.set_impersonation_session(session)-- app = _build_test_app()- async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver") as client:- response = await client.post("/mcp", headers={"x-api-key": "sk_live_admin"}, json={})-- assert response.status_code == 200- body = response.json()- assert body["api_key"] == "sk_live_target_key"- assert body["organization_id"] == "org_target"- assert body["admin_organization_id"] == "org_admin"- assert body["impersonation_target_organization_id"] == "org_target"---async def test_middleware_ignores_expired_session(monkeypatch: pytest.MonkeyPatch) -> None:- """Expired session is ignored — middleware reverts to admin's own org."""- monkeypatch.setattr(- mcp_http_auth,- "validate_mcp_api_key",- AsyncMock(- return_value=_build_validation(- "org_admin",- OrganizationAuthTokenType.mcp_admin_impersonation,- )- ),- )-- admin_hash = mcp_http_auth.cache_key("sk_live_admin")- session = mcp_http_auth.ImpersonationSession(- admin_api_key_hash=admin_hash,- admin_org_id="org_admin",- target_org_id="org_target",- target_api_key="sk_live_target_key",- expires_at=time.monotonic() - 1, # expired- ttl_minutes=1,- )- mcp_http_auth.set_impersonation_session(session)-- app = _build_test_app()- async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver") as client:- response = await client.post("/mcp", headers={"x-api-key": "sk_live_admin"}, json={})-- assert response.status_code == 200- body = response.json()- assert body["api_key"] == "sk_live_admin"- assert body["organization_id"] == "org_admin"- assert body["admin_organization_id"] is None---async def test_close_auth_db_clears_impersonation_sessions() -> None:- admin_hash = mcp_http_auth.cache_key("sk_admin_key")- session = mcp_http_auth.ImpersonationSession(- admin_api_key_hash=admin_hash,- admin_org_id="org_admin",- target_org_id="org_target",- target_api_key="sk_target_key",- expires_at=time.monotonic() + 600,- ttl_minutes=10,- )- mcp_http_auth.set_impersonation_session(session)-- dispose = AsyncMock()- mcp_http_auth._auth_db = SimpleNamespace(engine=SimpleNamespace(dispose=dispose))-- await mcp_http_auth.close_auth_db()-- assert mcp_http_auth.get_active_impersonation(admin_hash) is None