:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
"""Interactive OAuth consent for existing users.
The orchestrator redirects the user to GET /api/agentic/authorize; on approval
(automatic for trusted partners, via the in-app consent page otherwise) we
issue an auth code and redirect back to the orchestrator callback. The
pending/confirm endpoints back the in-app consent page, so unlike the rest of
this package they authenticate the browser session and speak the frontend's
plain error shapes, not the partner envelopes.
"""
from __future__ import annotations
import re
from typing import Any, cast
from urllib.parse import urlencode
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.core.cache import cache
from django.http import HttpResponseRedirect
from django.http.response import HttpResponseBase
from rest_framework.permissions import IsAuthenticated
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.views import APIView
from posthog.middleware import organization_block_page
from posthog.models.oauth import OAuthApplication
from posthog.models.team.team import Team
from posthog.models.user import User
from ee.api.agentic_provisioning.accounts import (
PartnerOrganizationChanged,
find_partner_organization,
get_callback_url,
get_or_create_partner_organization_team,
mint_pending_auth_code,
resolve_pending_partner,
)
from ee.api.agentic_provisioning.analytics import capture_provisioning_event
from ee.api.agentic_provisioning.constants import PENDING_AUTH_CACHE_PREFIX, SAFE_STATE_RE
from ee.api.agentic_provisioning.tokens import user_can_access_team
def _sanitize_state(state: str) -> str:
return re.sub(r"[^A-Za-z0-9_\-]", "", state)
def _partner_deactivated_redirect(pending_key: str) -> HttpResponseRedirect:
cache.delete(pending_key)
capture_provisioning_event("authorize", "partner_deactivated")
return HttpResponseRedirect(f"{settings.SITE_URL}?error=partner_deactivated")
def _consent_page_redirect(state: str) -> HttpResponseRedirect:
capture_provisioning_event("authorize", "selection_required")
base = settings.SITE_URL.rstrip("/")
params = urlencode({"state": _sanitize_state(state)})
return HttpResponseRedirect(f"{base}/agentic/authorize?{params}")
def _paying_partner(partner: OAuthApplication | None) -> OAuthApplication | None:
return partner if partner is not None and partner.provisioning.pays_for_customers else None
def _consent_changed_response(partner: OAuthApplication | None) -> Response:
capture_provisioning_event("authorize_confirm", "consent_changed", partner=partner)
return Response({"error": "consent_changed"}, status=409)
@login_required
def agentic_authorize(request: Any) -> HttpResponseBase:
state = request.GET.get("state", "")
if not state or not SAFE_STATE_RE.match(state):
capture_provisioning_event("authorize", "missing_state")
return HttpResponseRedirect(f"{settings.SITE_URL}?error=missing_state")
pending_key = f"{PENDING_AUTH_CACHE_PREFIX}{state}"
pending = cache.get(pending_key)
if pending is None:
capture_provisioning_event("authorize", "expired_state")
return HttpResponseRedirect(f"{settings.SITE_URL}?error=expired_or_invalid_state")
if request.user.email != pending["email"]:
capture_provisioning_event("authorize", "email_mismatch")
mismatch_params = urlencode(
{
"expected_email": pending["email"],
"current_email": request.user.email,
"partner_name": pending.get("partner_name", ""),
"state": state,
}
)
return HttpResponseRedirect(f"{settings.SITE_URL.rstrip('/')}/agentic/account-mismatch?{mismatch_params}")
user = request.user
partner_app = resolve_pending_partner(pending.get("partner_id", ""))
paying_partner = _paying_partner(partner_app)
if paying_partner is not None:
# The confirm step puts this partner's project in an organization the partner pays
# for, so no project of the user's is created, picked, or auto-approved here, and a
# user without an organization can still connect.
if not paying_partner.provisioning.active:
return _partner_deactivated_redirect(pending_key)
return _consent_page_redirect(state)
memberships = list(user.organization_memberships.select_related("organization").all())
if not memberships:
capture_provisioning_event("authorize", "no_organization")
return HttpResponseRedirect(f"{settings.SITE_URL}?error=no_organization")
# Only teams the user can actually reach are eligible: the auto-approve path
# below mints a code for non_demo_teams[0] without further checks.
org_ids = [m.organization_id for m in memberships]
non_demo_teams = [
team
for team in Team.objects.filter(organization_id__in=org_ids, is_demo=False)
if user_can_access_team(user, team)
]
if not non_demo_teams:
organization = memberships[0].organization
team = Team.objects.create_with_data(initiating_user=user, organization=organization)
non_demo_teams = [team]
capture_provisioning_event("authorize", "auto_created_project", team_id=team.id)
# Re-check partner is still active (could have been deactivated since account_requests)
is_trusted_partner = False
if partner_app is not None:
if not partner_app.provisioning.active:
return _partner_deactivated_redirect(pending_key)
# Fail closed: a partner-identified pending state missing the flag (e.g. created by an
# older pod mid-deploy) must still require consent, never silently auto-approve.
is_trusted_partner = partner_app.provisioning.skip_existing_user_consent and not pending.get(
"consent_required", True
)
if is_trusted_partner and len(memberships) == 1 and len(non_demo_teams) == 1:
organization = memberships[0].organization
team = non_demo_teams[0]
callback_url = get_callback_url(partner_app)
if callback_url is None:
capture_provisioning_event("authorize", "missing_callback")
return HttpResponseRedirect(f"{settings.SITE_URL}?error=missing_callback")
code = mint_pending_auth_code(pending, user_id=user.id, org_id=str(organization.id), team_id=team.id)
cache.delete(pending_key)
capture_provisioning_event("authorize", "auto_redirect", team_id=team.id)
params = urlencode({"code": code, "state": _sanitize_state(state)})
return HttpResponseRedirect(f"{callback_url}?{params}")
return _consent_page_redirect(state)
class AuthorizePendingView(APIView):
"""Return server-verified partner name, scopes and billing for a pending auth state.
The frontend calls this instead of reading from URL params, preventing
an attacker from spoofing the partner identity on the consent page.
"""
permission_classes = [IsAuthenticated]
def get(self, request: Request) -> Response:
state = request.query_params.get("state", "")
if not state or not SAFE_STATE_RE.match(state):
return Response({"error": "invalid_state"}, status=400)
pending = cache.get(f"{PENDING_AUTH_CACHE_PREFIX}{state}")
if pending is None:
return Response({"error": "expired_or_invalid_state"}, status=400)
user = cast(User, request.user)
if user.email != pending["email"]:
return Response({"error": "email_mismatch"}, status=403)
paying_partner = _paying_partner(resolve_pending_partner(pending.get("partner_id", "")))
partner_organization = find_partner_organization(user, paying_partner) if paying_partner is not None else None
return Response(
{
"partner_name": pending.get("partner_name", "the requesting app"),
"scopes": pending.get("scopes", []),
"pays_for_customers": paying_partner is not None,
"partner_organization_id": str(partner_organization.id) if partner_organization is not None else None,
"partner_organization_name": partner_organization.name if partner_organization is not None else None,
}
)
class AuthorizeConfirmView(APIView):
permission_classes = [IsAuthenticated]
def post(self, request: Request) -> Response:
state = request.data.get("state", "")
if not state or not SAFE_STATE_RE.match(state):
capture_provisioning_event("authorize_confirm", "invalid_request")
return Response({"error": "state and team_id are required"}, status=400)
pending_key = f"{PENDING_AUTH_CACHE_PREFIX}{state}"
pending = cache.get(pending_key)
if pending is None:
capture_provisioning_event("authorize_confirm", "expired_state")
return Response({"error": "expired_or_invalid_state"}, status=400)
user = cast(User, request.user)
if user.email != pending["email"]:
capture_provisioning_event("authorize_confirm", "email_mismatch")
return Response({"error": "email_mismatch"}, status=403)
confirm_partner = resolve_pending_partner(pending.get("partner_id", ""))
paying_partner = _paying_partner(confirm_partner)
if (request.data.get("pays_for_customers") is True) != (paying_partner is not None):
return _consent_changed_response(confirm_partner)
# A paying partner's consent page has no project picker, so it sends no team_id, and
# a team_id sent anyway is ignored.
team_id = request.data.get("team_id")
if team_id is None and paying_partner is None:
capture_provisioning_event("authorize_confirm", "invalid_request")
return Response({"error": "state and team_id are required"}, status=400)
if paying_partner is None:
try:
team = Team.objects.get(id=team_id, is_demo=False)
except Team.DoesNotExist:
capture_provisioning_event("authorize_confirm", "team_not_found", team_id=team_id)
return Response({"error": "team_not_found"}, status=404)
# The user picks the team here, so consent does not imply access: check
# team level too, or an org member excluded from a private project could
# approve a code scoped to it.
in_org = user.organization_memberships.filter(organization_id=team.organization_id).exists()
if (
not in_org
or not user_can_access_team(user, team)
or organization_block_page(team.organization) is not None
):
capture_provisioning_event("authorize_confirm", "team_not_accessible", team_id=team_id)
return Response({"error": "team_not_accessible"}, status=403)
if confirm_partner is not None and not confirm_partner.provisioning.active:
cache.delete(pending_key)
capture_provisioning_event("authorize_confirm", "partner_deactivated", partner=confirm_partner)
return Response({"error": "partner_deactivated"}, status=403)
callback_url = get_callback_url(confirm_partner)
if callback_url is None:
capture_provisioning_event("authorize_confirm", "missing_callback", partner=confirm_partner)
return Response({"error": "missing_callback"}, status=400)
success_properties: dict[str, object] = {}
if paying_partner is not None:
# Resolved only once every check above has passed, so a refused confirm leaves no
# organization behind.
try:
team, created = get_or_create_partner_organization_team(
user, paying_partner, approved_organization_id=request.data.get("partner_organization_id")
)
except PartnerOrganizationChanged:
return _consent_changed_response(confirm_partner)
success_properties["partner_organization"] = "created" if created else "reused"
# Mint the auth code BEFORE deleting pending state so a cache hiccup
# between the two doesn't leave the user with no recovery path.
code = mint_pending_auth_code(pending, user_id=user.id, org_id=str(team.organization_id), team_id=team.id)
cache.delete(pending_key)
params = urlencode({"code": code, "state": _sanitize_state(state)})
redirect_url = f"{callback_url}?{params}"
capture_provisioning_event(
"authorize_confirm", "success", partner=confirm_partner, team_id=team.id, **success_properties
)
return Response({"redirect_url": redirect_url})