mirror of
https://github.com/bytedance/deer-flow.git
synced 2026-07-28 00:48:07 +00:00
ee8ad1bc67
Add provider-agnostic OIDC authentication with Keycloak-compatible configuration, frontend SSO UI support
133 lines
4.4 KiB
Python
133 lines
4.4 KiB
Python
"""Local email/password authentication provider."""
|
|
|
|
import logging
|
|
|
|
from app.gateway.auth.models import User
|
|
from app.gateway.auth.password import hash_password_async, needs_rehash, verify_password_async
|
|
from app.gateway.auth.providers import AuthProvider
|
|
from app.gateway.auth.repositories.base import UserRepository
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class LocalAuthProvider(AuthProvider):
|
|
"""Email/password authentication provider using local database."""
|
|
|
|
def __init__(self, repository: UserRepository):
|
|
"""Initialize with a UserRepository.
|
|
|
|
Args:
|
|
repository: UserRepository implementation (SQLite)
|
|
"""
|
|
self._repo = repository
|
|
|
|
async def authenticate(self, credentials: dict) -> User | None:
|
|
"""Authenticate with email and password.
|
|
|
|
Args:
|
|
credentials: dict with 'email' and 'password' keys
|
|
|
|
Returns:
|
|
User if authentication succeeds, None otherwise
|
|
"""
|
|
email = credentials.get("email")
|
|
password = credentials.get("password")
|
|
|
|
if not email or not password:
|
|
return None
|
|
|
|
user = await self._repo.get_user_by_email(email)
|
|
if user is None:
|
|
return None
|
|
|
|
if user.password_hash is None:
|
|
# OAuth user without local password
|
|
return None
|
|
|
|
if not await verify_password_async(password, user.password_hash):
|
|
return None
|
|
|
|
if needs_rehash(user.password_hash):
|
|
try:
|
|
user.password_hash = await hash_password_async(password)
|
|
await self._repo.update_user(user)
|
|
except Exception:
|
|
# Rehash is an opportunistic upgrade; a transient DB error must not
|
|
# prevent an otherwise-valid login from succeeding.
|
|
logger.warning("Failed to rehash password for user %s; login will still succeed", user.email, exc_info=True)
|
|
|
|
return user
|
|
|
|
async def get_user(self, user_id: str) -> User | None:
|
|
"""Get user by ID."""
|
|
return await self._repo.get_user_by_id(user_id)
|
|
|
|
async def create_user(self, email: str, password: str | None = None, system_role: str = "user", needs_setup: bool = False) -> User:
|
|
"""Create a new local user.
|
|
|
|
Args:
|
|
email: User email address
|
|
password: Plain text password (will be hashed)
|
|
system_role: Role to assign ("admin" or "user")
|
|
needs_setup: If True, user must complete setup on first login
|
|
|
|
Returns:
|
|
Created User instance
|
|
"""
|
|
password_hash = await hash_password_async(password) if password else None
|
|
user = User(
|
|
email=email,
|
|
password_hash=password_hash,
|
|
system_role=system_role,
|
|
needs_setup=needs_setup,
|
|
)
|
|
return await self._repo.create_user(user)
|
|
|
|
async def get_user_by_oauth(self, provider: str, oauth_id: str) -> User | None:
|
|
"""Get user by OAuth provider and ID."""
|
|
return await self._repo.get_user_by_oauth(provider, oauth_id)
|
|
|
|
async def count_users(self) -> int:
|
|
"""Return total number of registered users."""
|
|
return await self._repo.count_users()
|
|
|
|
async def count_admin_users(self) -> int:
|
|
"""Return number of admin users."""
|
|
return await self._repo.count_admin_users()
|
|
|
|
async def update_user(self, user: User) -> User:
|
|
"""Update an existing user."""
|
|
return await self._repo.update_user(user)
|
|
|
|
async def get_user_by_email(self, email: str) -> User | None:
|
|
"""Get user by email."""
|
|
return await self._repo.get_user_by_email(email)
|
|
|
|
async def create_oauth_user(
|
|
self,
|
|
email: str,
|
|
oauth_provider: str,
|
|
oauth_id: str,
|
|
system_role: str = "user",
|
|
) -> User:
|
|
"""Create a new user from an OAuth/OIDC login.
|
|
|
|
Args:
|
|
email: Verified email from the OIDC provider
|
|
oauth_provider: Provider ID (e.g. 'keycloak', 'google')
|
|
oauth_id: User's subject claim from the ID token
|
|
system_role: Role to assign ("admin" or "user")
|
|
|
|
Returns:
|
|
Created User instance
|
|
"""
|
|
user = User(
|
|
email=email,
|
|
password_hash=None,
|
|
system_role=system_role,
|
|
needs_setup=False,
|
|
oauth_provider=oauth_provider,
|
|
oauth_id=oauth_id,
|
|
)
|
|
return await self._repo.create_user(user)
|