Enterprise agent platform for building, deploying, and operating AI teammates.
feat(composio): store an ordinary grant from the Composio callback (#3813)
蓝鱼bluefisha5decbc18fec
diff --git a/src/xagent/web/composio_auth.py b/src/xagent/web/composio_auth.pyindex b60fecfb7..49e71ebde 100644--- a/src/xagent/web/composio_auth.py+++ b/src/xagent/web/composio_auth.py@@ -32,14 +32,25 @@ for, and only accepted under, its app's own provider:are dropped, so a browser holds one actor's flows only.3. **Verify** (``?session_uri=`` only, sent by Composio's OAuth callbackidentity verification): the session names no flow, so every open flow's- checks run first, then ``complete_auth`` is called with that actor's- Composio user id, derived from *our* session. The account it activates+ checks run first, then ``complete_auth`` is called with the Composio user+ id of the flow's owner. The account it activatessays which flow this was; only that flow is spent. It must be ``ACTIVE``,of its app's auth config and toolkit. The app's own identity read throughthe proxy (``identity_url``, fixed or built from that account, with``identity_params``) gives the provider user id, which must match``identity_id_pattern``, and the grant is stored- for the app's runtime to execute. A refused completion spends nothing.+ for the app's runtime to execute. A completion refused after its flow is+ spent deletes the account it activated.++An ordinary (web) connect has no owner key and no actor link. Its start mints+the same signed state and single-use flow row, but binds the browser with the+ordinary OAuth proof cookie and its ``browser_nonce_hash`` claim; it is+accepted only as an ordinary flow, never as an actor one. Its Composio user id+is derived with an empty owner key, and its grant replaces the user's ordinary+row for the app (``resource_owner_key`` NULL) while actor rows are untouched.+Like the native callback, it also associates the user's catalog server in the+same transaction and refuses an app hidden from the connector catalog; actor+flows associate nothing.A begin needs a state carrying the Composio marker, a verification carries a``session_uri``, and a denied or failed authorization comes back to@@ -92,6 +103,7 @@ import hashlibimport hmacimport loggingimport re+import secretsimport threadingimport timefrom collections.abc import Callable, Iterable, Mapping@@ -107,6 +119,7 @@ from sqlalchemy import event, textfrom ..config import COMPOSIO_CALLBACK_URL as COMPOSIO_CALLBACK_URL_ENVfrom ..config import get_composio_callback_urlfrom ..core.utils import public_requests as requests+from .auth_sessions import lock_current_session_epochfrom .composio_apps import _GOOGLE_SUBJECT_RE as _GOOGLE_SUBJECT_REfrom .composio_apps import _GRAPH_ID_RE as _GRAPH_ID_REfrom .composio_apps import _SALESFORCE_HOST_RE as _SALESFORCE_HOST_RE@@ -209,6 +222,8 @@ _REQUEST_TIMEOUT_SECONDS = 10# Composio ids are short nanoid-style strings. Anything else is refused before# it is put in a URL path or stored._ACCOUNT_ID_RE = re.compile(r"[A-Za-z0-9_-]{1,128}")+# Flow nonces are hex digests, the same shape the actor flows use.+_FLOW_NONCE_RE = re.compile(r"[0-9a-f]{64}")_MAX_SESSION_URI_LENGTH = 4096Step = Literal["begin", "verify", "denied"]@@ -277,7 +292,11 @@ def _missing_config_names(app_id: str) -> list[str]:def composio_user_id(config: ComposioConfig, *, user_id: int, owner_key: str) -> str:- """One opaque Composio user per actor, never per workspace."""+ """One opaque Composio user per actor, or per user for an ordinary flow.++ An ordinary flow passes an empty owner key, so its HMAC input is+ ``"{user_id}:"``. Actor keys are never empty, so the two cannot coincide.+ """digest = hmac.new(config.user_id_secret.encode(),f"{user_id}:{owner_key}".encode(),@@ -1205,33 +1224,50 @@ async def run_missing_account_loop(# --- Browser trips -------------------------------------------------------------+Shape = Literal["actor", "ordinary"]++@dataclass(frozen=True)class _Flow:state: strnonce: struser_id: int- owner_key: str+ owner_key: str | Noneredirect: str | Noneexpires_at: floatapp_id: str+ shape: Shape+ session_epoch: str | None++ @property+ def actor_flow(self) -> bool:+ return self.shape == "actor"+++def _flow_actor(flow: _Flow) -> tuple[Shape, int, str | None]:+ """The fields that must be shared by every flow one browser completes."""+ return flow.shape, flow.user_id, flow.owner_keyclass _Rejected(Exception):- def __init__(self, reason: str, response: HTMLResponse) -> None:+ def __init__(+ self, reason: str, response: HTMLResponse, actor_flow: bool | None = None+ ) -> None:super().__init__(reason)self.reason = reasonself.response = response+ self.actor_flow = actor_flow-def _reject(reason: str) -> _Rejected:+def _reject(reason: str, actor_flow: bool | None = None) -> _Rejected:from .api.auth import (_actor_oauth_flow_rejected_response,_actor_oauth_flow_used_response,)if reason in {"flow_used_or_expired", "state_expired"}:- return _Rejected(reason, _actor_oauth_flow_used_response())- return _Rejected(reason, _actor_oauth_flow_rejected_response(reason))+ return _Rejected(reason, _actor_oauth_flow_used_response(), actor_flow)+ return _Rejected(reason, _actor_oauth_flow_rejected_response(reason), actor_flow)def _provider_of(app_id: str | None) -> str:@@ -1240,12 +1276,14 @@ def _provider_of(app_id: str | None) -> str:return app.provider if app is not None else UNKNOWN_APP_PROVIDER-def _log_rejection(reason: str, app_id: str | None = None) -> None:+def _log_rejection(+ reason: str, app_id: str | None = None, *, actor_flow: bool | None = None+) -> None:"""``app_id`` is unknown until the signed state has been read."""from .api.auth import _log_oauth_callback_rejection_log_oauth_callback_rejection(- _provider_of(app_id), reason, app_id=app_id, actor_flow=True+ _provider_of(app_id), reason, app_id=app_id, actor_flow=actor_flow)@@ -1262,6 +1300,28 @@ def _is_expired_composio_state(state: str) -> bool:)+def _verified_ordinary_flow(+ request: Any, db: Session, payload: Mapping[str, Any], *, nonce: Any, user_id: int+) -> None:+ """Check an ordinary flow's signed claims and browser proof cookie."""+ from .api.auth import _ordinary_oauth_cookie_name+ from .models.user import User++ if not isinstance(nonce, str) or _FLOW_NONCE_RE.fullmatch(nonce) is None:+ raise _reject("claims_invalid", False)+ browser_nonce_hash = payload.get("browser_nonce_hash")+ if browser_nonce_hash != nonce:+ raise _reject("claims_invalid", False)+ cookie_value = request.cookies.get(_ordinary_oauth_cookie_name(browser_nonce_hash))+ if not isinstance(cookie_value, str) or not cookie_value:+ raise _reject("cookie_missing", False)+ digest = hashlib.sha256(cookie_value.encode("ascii", "ignore")).hexdigest()+ if not secrets.compare_digest(browser_nonce_hash, digest):+ raise _reject("cookie_mismatch", False)+ if db.query(User.id).filter(User.id == user_id).one_or_none() is None:+ raise _reject("user_missing", False)++def _verified_flow(state: str, request: Any, db: Session) -> _Flow:"""Run every check that does not need Composio. Raises ``_Rejected``."""from .api.auth import (@@ -1293,18 +1353,27 @@ def _verified_flow(state: str, request: Any, db: Session) -> _Flow:or not isinstance(expires_at, (int, float))):raise _reject("claims_invalid")- try:- owner_key = check_actor_oauth_flow(- db,- request,- provider=COMPOSIO_APPS[app_id].provider,- user_id=user_id,- app_id=app_id,- nonce=nonce,- owner_claim=payload.get("resource_owner_key"),- )- except ActorOAuthFlowRejected as exc:- raise _reject(exc.reason) from None+ owner_claim = payload.get("resource_owner_key")+ if owner_claim is None:+ # An ordinary (web) flow: no actor link, proved instead by the same+ # browser cookie an ordinary OAuth start sets.+ _verified_ordinary_flow(request, db, payload, nonce=nonce, user_id=user_id)+ owner_key: str | None = None+ shape: Shape = "ordinary"+ else:+ try:+ owner_key = check_actor_oauth_flow(+ db,+ request,+ provider=COMPOSIO_APPS[app_id].provider,+ user_id=user_id,+ app_id=app_id,+ nonce=nonce,+ owner_claim=owner_claim,+ )+ except ActorOAuthFlowRejected as exc:+ raise _reject(exc.reason, True) from None+ shape = "actor"redirect = payload.get("redirect")return _Flow(state=state,@@ -1314,6 +1383,8 @@ def _verified_flow(state: str, request: Any, db: Session) -> _Flow:redirect=redirect if isinstance(redirect, str) else None,expires_at=float(expires_at),app_id=app_id,+ shape=shape,+ session_epoch=payload.get("session_epoch"),)@@ -1371,8 +1442,8 @@ class _OpenFlow:cookie_name: str@property- def actor(self) -> tuple[int, str]:- return self.flow.user_id, self.flow.owner_key+ def actor(self) -> tuple[Shape, int, str | None]:+ return _flow_actor(self.flow)@dataclass@@ -1384,6 +1455,8 @@ class _BrowserFlows:dead: list[str]# Why each dead flow failed its checks.reasons: list[str]+ # The shape of each dead flow, when its claims named one.+ shapes: list[bool | None]def _open_flows(request: Any, db: Session) -> _BrowserFlows:@@ -1391,6 +1464,7 @@ def _open_flows(request: Any, db: Session) -> _BrowserFlows:open_flows: list[_OpenFlow] = []dead: list[str] = []reasons: list[str] = []+ shapes: list[bool | None] = []for name, value in sorted(request.cookies.items()):if not name.startswith(FLOW_COOKIE_PREFIX):continue@@ -1398,21 +1472,23 @@ def _open_flows(request: Any, db: Session) -> _BrowserFlows:if decoded is None:dead.append(name)reasons.append("cookie_mismatch")+ shapes.append(None)continuestate, account_id = decodedtry:flow = _verified_flow(state, request, db)if name != _flow_cookie_name(flow.nonce):- raise _reject("cookie_mismatch")+ raise _reject("cookie_mismatch", flow.actor_flow)if _flow_row_query(db, flow.nonce).count() != 1:- raise _reject("flow_used_or_expired")+ raise _reject("flow_used_or_expired", flow.actor_flow)except _Rejected as rejected:dead.append(name)reasons.append(rejected.reason)+ shapes.append(rejected.actor_flow)continueopen_flows.append(_OpenFlow(flow, account_id, name))db.rollback()- return _BrowserFlows(open_flows, dead, reasons)+ return _BrowserFlows(open_flows, dead, reasons, shapes)def _clear_flow_cookies(@@ -1471,10 +1547,10 @@ def _handle_begin(request: Any, db: Session, callback: str) -> Response:try:flow = _verified_flow(state, request, db)if _flow_row_query(db, flow.nonce).count() != 1:- raise _reject("flow_used_or_expired")+ raise _reject("flow_used_or_expired", flow.actor_flow)except _Rejected as rejected:db.rollback()- _log_rejection(rejected.reason)+ _log_rejection(rejected.reason, actor_flow=rejected.actor_flow)return rejected.responsedb.rollback()@@ -1487,28 +1563,29 @@ def _handle_begin(request: Any, db: Session, callback: str) -> Response:stale = browser_flows.dead + [open_flow.cookie_namefor open_flow in existing- if open_flow.actor != (flow.user_id, flow.owner_key)- or open_flow.flow.nonce == flow.nonce+ if open_flow.actor != _flow_actor(flow) or open_flow.flow.nonce == flow.nonce]kept = [open_flow for open_flow in existing if open_flow.cookie_name not in stale]if len(kept) >= _MAX_OPEN_FLOWS:- _log_rejection("too_many_open_flows", flow.app_id)+ _log_rejection("too_many_open_flows", flow.app_id, actor_flow=flow.actor_flow)return _clear_flow_cookies(_too_many_flows_page(flow.app_id), callback, stale)config = load_config(flow.app_id)if config is None:- _log_rejection("composio_not_configured", flow.app_id)+ _log_rejection(+ "composio_not_configured", flow.app_id, actor_flow=flow.actor_flow+ )return _unavailable_page(flow.app_id)try:redirect_url, account_id = create_link(config,user_id=composio_user_id(- config, user_id=flow.user_id, owner_key=flow.owner_key+ config, user_id=flow.user_id, owner_key=flow.owner_key or ""),callback_url=callback,)except ComposioError as exc:- _log_rejection(exc.reason, flow.app_id)+ _log_rejection(exc.reason, flow.app_id, actor_flow=flow.actor_flow)return _unavailable_page(flow.app_id)# A reloaded begin replaces this flow's link. The previous link is not# deleted here: the original window may be completing it right now. If it@@ -1552,6 +1629,8 @@ def _handle_denied(request: Any, db: Session, callback: str) -> Response:matches = [f for f in browser_flows.open if returned and f.account_id == returned]app_ids = sorted({match.flow.app_id for match in matches})log_app = app_ids[0] if len(app_ids) == 1 else None+ matched_shapes = {match.flow.actor_flow for match in matches}+ actor_flow = matched_shapes.pop() if len(matched_shapes) == 1 else Nonefor match in matches:dead.append(match.cookie_name)_spend(db, match)@@ -1564,7 +1643,7 @@ def _handle_denied(request: Any, db: Session, callback: str) -> Response:"Composio returned a connection without verification; set the ""project's OAuth user verification to this callback URL")- _log_rejection("verification_not_configured", log_app)+ _log_rejection("verification_not_configured", log_app, actor_flow=actor_flow)return _clear_flow_cookies(_unavailable_page(*app_ids), callback, dead)provider = _provider_of(log_app)provider_error = _oauth_callback_provider_error(@@ -1575,7 +1654,7 @@ def _handle_denied(request: Any, db: Session, callback: str) -> Response:provider,"provider_error",app_id=log_app,- actor_flow=True,+ actor_flow=actor_flow,provider_error=provider_error,)return _clear_flow_cookies(@@ -1615,15 +1694,24 @@ def _handle_verify(request: Any, db: Session, callback: str) -> Response:browser_flows = _open_flows(request, db)open_flows, dead = browser_flows.open, browser_flows.deadif not open_flows:- reasons = browser_flows.reasons- reason = reasons[-1] if reasons else "cookie_missing"- _log_rejection(reason)- return _clear_flow_cookies(_reject(reason).response, callback, dead)+ if browser_flows.reasons:+ # The reason and its shape come from the same cookie.+ reason = browser_flows.reasons[-1]+ actor_flow = browser_flows.shapes[-1]+ else:+ reason, actor_flow = "cookie_missing", None+ _log_rejection(reason, actor_flow=actor_flow)+ return _clear_flow_cookies(_reject(reason, actor_flow).response, callback, dead)actors = {open_flow.actor for open_flow in open_flows}+ shapes = {open_flow.flow.actor_flow for open_flow in open_flows}if len(actors) != 1:- # begin keeps one actor per browser; anything else is not completed.- _log_rejection("claims_invalid")- return _clear_flow_cookies(_reject("claims_invalid").response, callback, dead)+ # begin keeps one actor and one flow shape per browser; anything else+ # is not completed.+ actor_flow = shapes.pop() if len(shapes) == 1 else None+ _log_rejection("claims_invalid", actor_flow=actor_flow)+ return _clear_flow_cookies(+ _reject("claims_invalid", actor_flow).response, callback, dead+ )# A browser can hold flows of several apps for the same actor at once# (Facebook and Instagram, say). They share the project's API key and the@@ -1633,23 +1721,24 @@ def _handle_verify(request: Any, db: Session, callback: str) -> Response:# identity checked. One app's missing config never blocks the other's.app_ids = sorted({open_flow.flow.app_id for open_flow in open_flows})log_app = app_ids[0] if len(app_ids) == 1 else None+ actor_flow = next(iter(shapes))configs = _configured_apps()if not configs:- _log_rejection("composio_not_configured", log_app)+ _log_rejection("composio_not_configured", log_app, actor_flow=actor_flow)return _clear_flow_cookies(_unavailable_page(*app_ids), callback, dead)shared = next(iter(configs.values()))- user_id, owner_key = actors.pop()- composio_user = composio_user_id(shared, user_id=user_id, owner_key=owner_key)+ _shape, user_id, owner_key = actors.pop()+ composio_user = composio_user_id(shared, user_id=user_id, owner_key=owner_key or "")try:account_id = complete_auth(shared, session_uri=session_uri, user_id=composio_user)except ComposioError as exc:- _log_rejection(exc.reason, log_app)+ _log_rejection(exc.reason, log_app, actor_flow=actor_flow)if exc.rejected:# Nothing was activated, so every open flow stays usable.return _clear_flow_cookies(- _reject("composio_rejected").response, callback, dead+ _reject("composio_rejected", actor_flow).response, callback, dead)# Composio may have activated an account before the answer was lost;# which one cannot be told here. Nothing is spent or deleted: an@@ -1664,9 +1753,9 @@ def _handle_verify(request: Any, db: Session, callback: str) -> Response:# member was signing in). It is not bound here; if it is ours and# stays unbound, the reconciler removes it.logger.warning("Composio completed a connection no open flow created")- _log_rejection("account_invalid", log_app)+ _log_rejection("account_invalid", log_app, actor_flow=actor_flow)return _clear_flow_cookies(- _reject("composio_rejected").response, callback, dead+ _reject("composio_rejected", actor_flow).response, callback, dead)match = matches[0]app_id = match.flow.app_id@@ -1674,16 +1763,16 @@ def _handle_verify(request: Any, db: Session, callback: str) -> Response:if not _spend(db, match):# Spent by another request (which binds it) or expired meanwhile (the# reconciler then removes the unbound account). Never delete here.- _log_rejection("flow_used_or_expired", app_id)+ _log_rejection("flow_used_or_expired", app_id, actor_flow=actor_flow)return _clear_flow_cookies(- _reject("flow_used_or_expired").response, callback, dead+ _reject("flow_used_or_expired", actor_flow).response, callback, dead)# This request spent the flow that created the account, so the account is# its own: if it cannot be bound, it is deleted rather than left unbound.config = configs.get(app_id)if config is None:# This app's config went away after its flow began.- _log_rejection("composio_not_configured", app_id)+ _log_rejection("composio_not_configured", app_id, actor_flow=actor_flow)delete_account(shared.api_key, account_id)return _clear_flow_cookies(_unavailable_page(app_id), callback, dead)try:@@ -1708,17 +1797,21 @@ def _handle_verify(request: Any, db: Session, callback: str) -> Response:provider_user_id=provider_user_id,)except ComposioError as exc:- _log_rejection(exc.reason, app_id)+ _log_rejection(exc.reason, app_id, actor_flow=actor_flow)delete_account(config.api_key, account_id)if exc.reason == "identity_host_invalid":response = _identity_host_invalid_page(app_id)elif exc.rejected:- response = _reject("composio_rejected").response+ response = _reject("composio_rejected", actor_flow).responseelse:response = _unavailable_page(app_id)return _clear_flow_cookies(response, callback, dead)except _Rejected as rejected:- _log_rejection(rejected.reason, app_id)+ _log_rejection(+ rejected.reason,+ app_id,+ actor_flow=rejected.actor_flow,+ )delete_account(config.api_key, account_id)return _clear_flow_cookies(rejected.response, callback, dead)except Exception as exc:@@ -1744,6 +1837,32 @@ def _handle_verify(request: Any, db: Session, callback: str) -> Response:return _clear_flow_cookies(stored, callback, dead)+def _ordinary_catalog_app(db: Session, app_id: str) -> dict[str, Any] | None:+ """The catalog app an ordinary grant also associates; a hidden one is refused."""+ from fastapi import HTTPException++ from .api.mcp import _reject_hidden_catalog_app+ from .mcp_apps import get_app_by_id++ app_info = get_app_by_id(db, app_id)+ if app_info is None:+ return None+ try:+ _reject_hidden_catalog_app(app_info)+ except HTTPException:+ raise _Rejected(+ "app_hidden",+ HTMLResponse(+ content=(+ "<h1>Cannot Connect</h1><p>This app is not currently available.</p>"+ ),+ status_code=404,+ ),+ False,+ ) from None+ return app_info++def _store_grant(db: Session,*,@@ -1757,20 +1876,31 @@ def _store_grant(from .models.user_oauth import UserOAuthfrom .services.user_oauth import delete_scoped_user_oauth_accounts- try:- # Composio I/O can overlap a personal disconnect.- _lock_actor_link(- db,- user_id=flow.user_id,- provider=COMPOSIO_APPS[flow.app_id].provider,- app_id=flow.app_id,- )- except ValueError:- db.rollback()- raise _reject("link_changed_after_exchange") from None+ app_info = None if flow.actor_flow else _ordinary_catalog_app(db, flow.app_id)+ if flow.actor_flow:+ try:+ # Composio I/O can overlap a personal disconnect.+ _lock_actor_link(+ db,+ user_id=flow.user_id,+ provider=COMPOSIO_APPS[flow.app_id].provider,+ app_id=flow.app_id,+ )+ except ValueError:+ db.rollback()+ raise _reject("link_changed_after_exchange", True) from Nonedb.query(User.id).filter(User.id == flow.user_id).with_for_update().one()- # Replaces this actor's previous grant for the app; a previous Composio- # account is deleted once this commits.+ if not flow.actor_flow and not lock_current_session_epoch(+ db, flow.user_id, flow.session_epoch+ ):+ db.rollback()+ raise _reject("session_epoch_changed_after_exchange", False) from None+ if app_info is not None:+ from .api.auth import _ensure_user_mcp_server++ _ensure_user_mcp_server(db, flow.user_id, app_info)+ # Replaces this flow owner's own row for the app, never another owner's;+ # a replaced Composio account is deleted once this commits.delete_scoped_user_oauth_accounts(db,user_id=flow.user_id,diff --git a/tests/web/test_composio_ordinary_flow.py b/tests/web/test_composio_ordinary_flow.pynew file mode 100644index 000000000..d8fe63210--- /dev/null+++ b/tests/web/test_composio_ordinary_flow.py@@ -0,0 +1,659 @@+"""An ordinary (web) connect completes through Composio-hosted auth.++No start emits such a state yet, so these tests mint it the way the later+start will: the Composio auth-backend claim, no ``resource_owner_key``, the+ordinary browser proof cookie named by the state's ``browser_nonce_hash``+claim, and a single-use flow row the verify or denied trip spends.++Composio is faked by the Facebook connect tests; no request leaves the+process.+"""++from __future__ import annotations++import hashlib+import logging+import secrets+from datetime import datetime, timedelta, timezone+from types import SimpleNamespace+from urllib.parse import parse_qs, urlsplit++import pytest++from xagent.web import composio_auth+from xagent.web.api import auth as auth_api+from xagent.web.api.mcp import list_mcp_apps+from xagent.web.models.actor_oauth_flow import ActorOAuthFlowState+from xagent.web.models.mcp import MCPServer, UserMCPServer+from xagent.web.models.public_mcp import PublicMCPApp+from xagent.web.models.user import User+from xagent.web.services.user_oauth import (+ delete_scoped_user_oauth_accounts,+ normalize_user_oauth_resource_owner_key,+)++from . import test_composio_facebook_connect as facebook_connect+from .test_composio_facebook_connect import (+ CALLBACK_PATH,+ CALLBACK_URL,+ FACEBOOK_USER_ID,+)+from .test_composio_facebook_connect import NOW as RECONCILE_NOW+from .test_composio_facebook_connect import (+ OTHER_OWNER,+ OWNER,+ Browser,+ FakeComposio,+ _denied_url,+ _flow_cookies,+ _grants,+ _listed,+ _store_composio_grant,+ _verify_url,+)++composio_env = facebook_connect.composio_env+db_session = facebook_connect.db_session+composio = facebook_connect.composio++MISSING_ACCOUNT = facebook_connect.MISSING_ACCOUNT+++def ordinary(db_session, composio_env, composio):+ """A user with no actor link at all: an ordinary connect needs none."""+ db, user = db_session+ db.query(UserMCPServer).delete()+ db.commit()+ return db, user, composio+++DEDICATED_URL = "https://app.example.com/api/auth/composio/callback"+DEDICATED_PATH = "/api/auth/composio/callback"+++class RoutedBrowser(Browser):+ """A browser whose requests reach whichever callback route they name."""++ def get(self, db, url):+ parts = urlsplit(url)+ if parts.path == CALLBACK_PATH:+ return super().get(db, url)+ assert parts.path == DEDICATED_PATH, parts.path+ query = {name: values[0] for name, values in parse_qs(parts.query).items()}+ request = SimpleNamespace(query_params=query, cookies=self.for_path(parts.path))+ response = auth_api.composio_oauth_callback(request, db)+ self.receive(response)+ return response+++def dedicated_ordinary(ordinary, monkeypatch):+ monkeypatch.setenv("XAGENT_COMPOSIO_CALLBACK_URL", DEDICATED_URL)+ return ordinary+++def _mint_ordinary_state(+ db,+ user,+ browser: Browser,+ *,+ expired: bool = False,+ with_browser_nonce_claim: bool = True,+ app_id: str = "facebook",+ provider: str = "meta",+ cookie_path: str = CALLBACK_PATH,+ actor_flow_nonce: str | None = None,+) -> str:+ """The state the later Composio start will mint for a web connect."""+ browser_nonce = secrets.token_urlsafe(32)+ nonce = hashlib.sha256(browser_nonce.encode()).hexdigest()+ data = {+ "type": "oauth_state",+ "user_id": int(user.id),+ "provider": provider,+ "app_id": app_id,+ "redirect": None,+ "session_epoch": user.session_epoch,+ composio_auth.AUTH_BACKEND_CLAIM: composio_auth.AUTH_BACKEND,+ "actor_flow_nonce": actor_flow_nonce or nonce,+ }+ if with_browser_nonce_claim:+ data["browser_nonce_hash"] = nonce+ state = auth_api.create_access_token(data=data, expires_delta=timedelta(minutes=10))+ expires_at = datetime.now(timezone.utc) + timedelta(minutes=10)+ if expired:+ expires_at = datetime.now(timezone.utc) - timedelta(seconds=1)+ db.add(ActorOAuthFlowState(nonce=nonce, expires_at=expires_at))+ db.commit()+ browser.cookies[auth_api._ordinary_oauth_cookie_name(nonce)] = (+ browser_nonce,+ cookie_path,+ )+ return state+++def _begin(db, browser: Browser, state: str):+ return browser.get(db, composio_auth.begin_location(CALLBACK_URL, state))+++def _connect_ordinary(db, user, composio: FakeComposio) -> tuple[str, Browser]:+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser)+ assert _begin(db, browser, state).status_code == 302+ response = browser.get(db, _verify_url(composio))+ assert response.status_code == 200, response.body+ return composio.created[-1], browser+++def _ordinary_grants(db):+ db.expire_all()+ return [grant for grant in _grants(db) if grant.resource_owner_key is None]+++def _ordinary_composio_user(user) -> str:+ config = composio_auth.load_config("facebook")+ assert config is not None+ return composio_auth.composio_user_id(config, user_id=int(user.id), owner_key="")+++# --- The flow -------------------------------------------------------------------+++def test_an_ordinary_flow_begins_verifies_and_stores_an_ordinary_grant(ordinary):+ db, user, composio = ordinary+ _store_composio_grant(db, user, account_id="ca_actor", owner=OWNER)+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser)++ begin = _begin(db, browser, state)++ assert begin.status_code == 302, begin.body+ link = [body for _, path, body in composio.calls if path.endswith("/link")]+ ordinary_user = _ordinary_composio_user(user)+ assert link == [+ {+ "auth_config_id": facebook_connect.AUTH_CONFIG_ID,+ "user_id": ordinary_user,+ "callback_url": CALLBACK_URL,+ }+ ]++ response = browser.get(db, _verify_url(composio))++ assert response.status_code == 200, response.body+ account = composio.created[-1]+ (stored,) = _ordinary_grants(db)+ assert stored.provider == "facebook"+ assert stored.token_type == "composio"+ assert stored.access_token == account+ assert stored.provider_user_id == FACEBOOK_USER_ID+ assert stored.instance_url == ordinary_user+ assert stored.refresh_token is None+ # The user's actor grant is untouched.+ actor = [grant for grant in _grants(db) if grant.resource_owner_key == OWNER]+ assert [grant.access_token for grant in actor] == ["ca_actor"]+ assert db.query(ActorOAuthFlowState).count() == 0+ assert _flow_cookies(browser) == []+ assert composio.paths("DELETE") == []+++def test_a_second_ordinary_connect_replaces_the_first_and_deletes_its_account(+ ordinary,+):+ db, user, composio = ordinary+ _store_composio_grant(db, user, account_id="ca_actor", owner=OWNER)+ first, _ = _connect_ordinary(db, user, composio)++ second, _ = _connect_ordinary(db, user, composio)++ (stored,) = _ordinary_grants(db)+ assert second != first+ assert stored.access_token == second+ assert composio.paths("DELETE") == [f"/connected_accounts/{first}"]+ actor = [grant for grant in _grants(db) if grant.resource_owner_key == OWNER]+ assert [grant.access_token for grant in actor] == ["ca_actor"]+++def test_the_ordinary_composio_user_cannot_collide_with_an_actor_of_the_same_user(+ composio_env,+):+ config = composio_auth.load_config("facebook")+ assert config is not None+ ordinary = composio_auth.composio_user_id(config, user_id=7, owner_key="")+ actors = {+ composio_auth.composio_user_id(config, user_id=7, owner_key=owner)+ for owner in (OWNER, OTHER_OWNER)+ }+ assert ordinary not in actors+ assert ordinary == composio_auth.composio_user_id(config, user_id=7, owner_key="")+ # An actor owner key can never be empty, so the two forms cannot coincide.+ for blank in ("", " "):+ with pytest.raises(ValueError):+ normalize_user_oauth_resource_owner_key(blank)+++# --- The connector association ---------------------------------------------------+++def _listed_app(db, user, app_id: str = "facebook") -> dict:+ apps = list_mcp_apps(location="remote", current_user=user, db=db)+ return {app["id"]: app for app in apps}[app_id]+++def test_an_ordinary_connect_associates_the_connector(ordinary):+ """A first-time member's listing says connected only with a grant and the+ user's server association, so the ordinary store writes both."""+ db, user, composio = ordinary+ db.query(MCPServer).delete()+ db.commit()+ assert _listed_app(db, user)["is_connected"] is False++ _connect_ordinary(db, user, composio)++ (association,) = db.query(UserMCPServer).all()+ assert int(association.user_id) == int(user.id)+ assert association.is_owner+ assert association.is_active+ assert _listed_app(db, user)["is_connected"] is True+++def test_an_actor_connect_associates_no_connector(+ db_session, composio_env, composio, monkeypatch+):+ """An actor flow's link must already exist, so assert the store never asks+ for one: an ensure here would be a no-op and hide the regression."""+ db, user = db_session+ ensured = []+ real = auth_api._ensure_user_mcp_server++ def spy(*args, **kwargs):+ ensured.append(args)+ return real(*args, **kwargs)++ monkeypatch.setattr(auth_api, "_ensure_user_mcp_server", spy)+ browser, _ = facebook_connect._connect_until_verification(db, user, OWNER)++ assert browser.get(db, _verify_url(composio)).status_code == 200++ assert [grant.resource_owner_key for grant in _grants(db)] == [OWNER]+ assert ensured == []+ assert db.query(UserMCPServer).count() == 1+++def test_a_hidden_app_stores_nothing_and_its_account_is_deleted(ordinary):+ db, user, composio = ordinary+ db.query(PublicMCPApp).filter(PublicMCPApp.app_id == "facebook").update(+ {PublicMCPApp.is_visible_in_connector: False}+ )+ db.commit()+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser)+ assert _begin(db, browser, state).status_code == 302+ account = composio.created[-1]++ response = browser.get(db, _verify_url(composio, account))++ assert response.status_code == 404+ assert "not currently available" in response.body.decode()+ assert _ordinary_grants(db) == []+ assert db.query(UserMCPServer).count() == 0+ assert db.query(ActorOAuthFlowState).count() == 0+ assert composio.paths("DELETE") == [f"/connected_accounts/{account}"]+++def test_a_failed_association_stores_nothing_and_its_account_is_deleted(+ ordinary, monkeypatch+):+ db, user, composio = ordinary++ def conflict(*_args, **_kwargs):+ raise ValueError("catalog metadata conflict")++ monkeypatch.setattr(auth_api, "_ensure_user_mcp_server", conflict)+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser)+ assert _begin(db, browser, state).status_code == 302+ account = composio.created[-1]++ response = browser.get(db, _verify_url(composio, account))++ assert response.status_code == 500+ assert _ordinary_grants(db) == []+ assert db.query(UserMCPServer).count() == 0+ assert composio.paths("DELETE") == [f"/connected_accounts/{account}"]+++# --- Proof cookie and one-time use ----------------------------------------------+++def test_replaying_a_spent_ordinary_flow_creates_no_link(ordinary):+ db, user, composio = ordinary+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser)+ assert _begin(db, browser, state).status_code == 302+ spent_cookies = dict(browser.cookies)+ assert browser.get(db, _verify_url(composio)).status_code == 200++ browser.cookies = dict(spent_cookies)+ replay_verify = browser.get(db, _verify_url(composio))+ browser.cookies = dict(spent_cookies)+ replay_begin = _begin(db, browser, state)++ assert replay_verify.status_code == 400+ assert replay_begin.status_code == 400+ assert "already been used" in replay_begin.body.decode()+ assert composio.paths().count("/connected_accounts/complete_auth") == 1+ assert composio.paths().count("/connected_accounts/link") == 1+ assert len(_ordinary_grants(db)) == 1+++def test_an_ordinary_begin_without_its_browser_proof_creates_no_link(ordinary):+ db, user, composio = ordinary+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser)+ browser.cookies = {}++ response = _begin(db, browser, state)++ assert response.status_code == 400+ assert "same browser" in response.body.decode()+ assert composio.calls == []+ assert db.query(ActorOAuthFlowState).count() == 1+++def test_an_ordinary_begin_with_a_foreign_browser_proof_creates_no_link(ordinary):+ db, user, composio = ordinary+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser)+ (name,) = browser.cookies+ browser.cookies[name] = ("someone-elses-proof", CALLBACK_PATH)++ response = _begin(db, browser, state)++ assert response.status_code == 400+ assert composio.calls == []+ assert db.query(ActorOAuthFlowState).count() == 1+++def test_an_ordinary_state_without_its_browser_nonce_claim_creates_no_link(ordinary):+ db, user, composio = ordinary+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser, with_browser_nonce_claim=False)++ response = _begin(db, browser, state)++ assert response.status_code == 400+ assert composio.calls == []+++def test_an_ordinary_state_whose_two_nonce_claims_disagree_is_refused(ordinary):+ """The proof cookie matches ``browser_nonce_hash``, so only the inequality+ with ``actor_flow_nonce`` can refuse this."""+ db, user, composio = ordinary+ browser = Browser()+ state = _mint_ordinary_state(+ db,+ user,+ browser,+ actor_flow_nonce=hashlib.sha256(secrets.token_urlsafe(32).encode()).hexdigest(),+ )++ response = _begin(db, browser, state)++ assert response.status_code == 400+ assert "could not be verified" in response.body.decode()+ assert composio.calls == []+ assert db.query(ActorOAuthFlowState).count() == 1+++def test_an_expired_ordinary_flow_creates_no_link(ordinary):+ db, user, composio = ordinary+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser, expired=True)++ response = _begin(db, browser, state)++ assert response.status_code == 400+ assert "already been used" in response.body.decode()+ assert composio.calls == []+ assert _ordinary_grants(db) == []+++# --- Session fence ----------------------------------------------------------------+++def test_a_session_epoch_rotated_during_the_flow_stores_nothing(ordinary, caplog):+ """A password change/reset during the sign-in wins: no row is written, and+ the flow is already spent so a retry cannot quietly store it."""+ db, user, composio = ordinary+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser)+ assert _begin(db, browser, state).status_code == 302+ account = composio.created[-1]+ db.query(User).filter(User.id == int(user.id)).update(+ {User.session_epoch: "rotated"}+ )+ db.commit()+ caplog.set_level(logging.WARNING)++ response = browser.get(db, _verify_url(composio, account))++ assert response.status_code == 400+ assert "reason=session_epoch_changed_after_exchange" in caplog.text+ assert "actor_flow=false" in caplog.text+ assert _ordinary_grants(db) == []+ assert db.query(ActorOAuthFlowState).count() == 0+ retry = browser.get(db, _verify_url(composio, account))+ assert retry.status_code == 400+ assert _ordinary_grants(db) == []+ # The account this request activated is deleted, not left unbound.+ assert composio.paths("DELETE") == [f"/connected_accounts/{account}"]+++# --- One shape is never the other ------------------------------------------------+++def test_an_ordinary_state_is_not_accepted_on_the_actor_path(ordinary):+ """The actor proof cookie (whose digest matches the nonce too) may not+ stand in for the ordinary browser proof."""+ db, user, composio = ordinary+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser)+ payload = auth_api.verify_token(state)+ assert payload is not None+ (proof_name,) = browser.cookies+ proof_value = browser.cookies.pop(proof_name)[0]+ browser.cookies[auth_api._actor_oauth_cookie_name(payload["actor_flow_nonce"])] = (+ proof_value,+ CALLBACK_PATH,+ )++ response = _begin(db, browser, state)++ assert response.status_code == 400+ assert composio.calls == []+ assert _ordinary_grants(db) == []+++def test_an_actor_state_is_not_accepted_on_the_ordinary_path(+ db_session, composio_env, composio+):+ db, user = db_session+ browser = Browser()+ start = facebook_connect._start(db, user, browser, OWNER)+ actor_cookie = next(+ name+ for name in browser.cookies+ if name.startswith(auth_api._ACTOR_OAUTH_COOKIE_PREFIX)+ )+ browser.cookies.pop(actor_cookie)+ browser_nonce = secrets.token_urlsafe(32)+ browser.cookies[+ auth_api._ordinary_oauth_cookie_name(+ hashlib.sha256(browser_nonce.encode()).hexdigest()+ )+ ] = (browser_nonce, CALLBACK_PATH)++ response = browser.get(db, start.headers["location"])++ assert response.status_code == 400+ assert composio.calls == []+ assert _grants(db) == []+++def test_a_browser_holding_both_shapes_completes_neither(+ db_session, composio_env, composio+):+ db, user = db_session+ browser = Browser()+ start = facebook_connect._start(db, user, browser, OWNER)+ assert browser.get(db, start.headers["location"]).status_code == 302+ (actor_flow_cookie,) = _flow_cookies(browser)+ actor_flow = browser.cookies[actor_flow_cookie]+ ordinary_state = _mint_ordinary_state(db, user, browser)+ assert _begin(db, browser, ordinary_state).status_code == 302+ ordinary_account = composio.created[-1]+ # Both flow cookies open at once: one browser, two shapes.+ browser.cookies[actor_flow_cookie] = actor_flow++ response = browser.get(db, _verify_url(composio, ordinary_account))++ assert response.status_code == 400+ assert composio.paths().count("/connected_accounts/complete_auth") == 0+ assert _grants(db) == []+ assert db.query(ActorOAuthFlowState).count() == 2+++def test_an_ordinary_begin_drops_the_actor_flow_cookie_it_finds(+ db_session, composio_env, composio+):+ db, user = db_session+ browser = Browser()+ start = facebook_connect._start(db, user, browser, OWNER)+ assert browser.get(db, start.headers["location"]).status_code == 302+ (actor_flow_cookie,) = _flow_cookies(browser)++ begin = _begin(db, browser, _mint_ordinary_state(db, user, browser))++ assert begin.status_code == 302+ assert actor_flow_cookie not in browser.cookies+ assert len(_flow_cookies(browser)) == 1+++def test_an_actor_begin_drops_the_ordinary_flow_cookie_it_finds(+ db_session, composio_env, composio+):+ db, user = db_session+ browser = Browser()+ assert (+ _begin(db, browser, _mint_ordinary_state(db, user, browser)).status_code == 302+ )+ (ordinary_flow_cookie,) = _flow_cookies(browser)++ start = facebook_connect._start(db, user, browser, OWNER)+ begin = browser.get(db, start.headers["location"])++ assert begin.status_code == 302+ assert ordinary_flow_cookie not in browser.cookies+ assert len(_flow_cookies(browser)) == 1+++# --- The dedicated callback -----------------------------------------------------+++def test_an_ordinary_flow_completes_on_the_dedicated_callback(dedicated_ordinary):+ """The proof cookie sits on the path an ordinary start sets: the shared+ callback, here the dedicated route rather than the Meta one."""+ db, user, composio = dedicated_ordinary+ browser = RoutedBrowser()+ state = _mint_ordinary_state(db, user, browser, cookie_path=DEDICATED_PATH)++ begin = browser.get(db, f"{DEDICATED_URL}?state={state}")++ assert begin.status_code == 302, begin.body+ (link,) = [body for _, path, body in composio.calls if path.endswith("/link")]+ assert link["callback_url"] == DEDICATED_URL+ assert link["user_id"] == _ordinary_composio_user(user)++ verify = browser.get(+ db, f"{DEDICATED_URL}?session_uri={_verify_url(composio).split('=', 1)[1]}"+ )++ assert verify.status_code == 200, verify.body+ (stored,) = _ordinary_grants(db)+ assert stored.resource_owner_key is None+ assert stored.access_token == composio.created[-1]+ assert _flow_cookies(browser) == []+++# --- Denial logs ----------------------------------------------------------------+++def test_a_denied_ordinary_flow_is_logged_as_an_ordinary_flow(ordinary, caplog):+ db, user, composio = ordinary+ browser = Browser()+ state = _mint_ordinary_state(db, user, browser)+ assert _begin(db, browser, state).status_code == 302+ caplog.set_level(logging.WARNING)++ response = browser.get(db, _denied_url(composio.created[-1]))++ assert response.status_code == 400+ assert "Permission was not granted" in response.body.decode()+ assert "provider=meta app_id=facebook actor_flow=false" in caplog.text+ assert "reason=provider_error" in caplog.text+ assert db.query(ActorOAuthFlowState).count() == 0+++# --- The background passes and disconnect ---------------------------------------+++def test_the_missing_account_pass_tombstones_an_ordinary_row(ordinary, monkeypatch):+ db, user, composio = ordinary+ monkeypatch.setattr(composio_auth, "_missing_account_cursor", 0)+ _store_composio_grant(db, user, account_id="ca_gone", owner=None)+ composio.account_lookup["ca_gone"] = (404, MISSING_ACCOUNT)++ assert composio_auth.tombstone_missing_composio_accounts(db) == 1++ (stored,) = _ordinary_grants(db)+ assert stored.resource_owner_key is None+ assert stored.access_token == ""+ assert stored.refresh_token is None+++def test_the_orphan_pass_counts_an_ordinary_row_as_a_reference(ordinary):+ db, user, composio = ordinary+ _store_composio_grant(db, user, account_id="ca_bound", owner=None)+ composio.listing[""] = {"items": [_listed("ca_bound"), _listed("ca_orphan")]}++ assert composio_auth.reconcile_orphan_accounts(db, now=RECONCILE_NOW) == 1++ assert composio.paths("DELETE") == ["/connected_accounts/ca_orphan"]+ assert [grant.access_token for grant in _ordinary_grants(db)] == ["ca_bound"]+++def test_the_web_disconnect_schedules_deletion_of_an_ordinary_account(ordinary):+ """The web disconnect calls this with ``resource_owner_key=None``+ (api/mcp.py); it must delete the Composio account too."""+ db, user, composio = ordinary+ _store_composio_grant(db, user, account_id="ca_web", owner=None)+ _store_composio_grant(db, user, account_id="ca_actor", owner=OWNER)++ deleted = delete_scoped_user_oauth_accounts(+ db,+ user_id=int(user.id),+ resource_owner_key=None,+ providers=["facebook"],+ )+ assert deleted == 1+ assert composio.calls == []++ db.commit()++ assert composio.paths("DELETE") == ["/connected_accounts/ca_web"]+ grants = _grants(db)+ assert [(grant.resource_owner_key, grant.access_token) for grant in grants] == [+ (OWNER, "ca_actor")+ ]