Skip to content

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.py
index 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 callback
identity 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 activates
says 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 through
the 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 hashlib
import hmac
import logging
import re
+import secrets
import threading
import time
from collections.abc import Callable, Iterable, Mapping
@@ -107,6 +119,7 @@ from sqlalchemy import event, text
from ..config import COMPOSIO_CALLBACK_URL as COMPOSIO_CALLBACK_URL_ENV
from ..config import get_composio_callback_url
from ..core.utils import public_requests as requests
+from .auth_sessions import lock_current_session_epoch
from .composio_apps import _GOOGLE_SUBJECT_RE as _GOOGLE_SUBJECT_RE
from .composio_apps import _GRAPH_ID_RE as _GRAPH_ID_RE
from .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 = 4096
Step = 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: str
nonce: str
user_id: int
- owner_key: str
+ owner_key: str | None
redirect: str | None
expires_at: float
app_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_key
class _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 = reason
self.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)
continue
state, account_id = decoded
try:
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)
continue
open_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.response
db.rollback()
@@ -1487,28 +1563,29 @@ def _handle_begin(request: Any, db: Session, callback: str) -> Response:
stale = browser_flows.dead + [
open_flow.cookie_name
for 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 None
for 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.dead
if 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).response
else:
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 UserOAuth
from .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 None
db.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.py
new file mode 100644
index 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")
+ ]