vibetuner 2.6.1__py3-none-any.whl → 2.7.1__py3-none-any.whl

vibetuner/frontend/routes/auth.py

@@ -0,0 +1,150 @@
+from typing import Annotated
+
+from fastapi import (
+    APIRouter,
+    BackgroundTasks,
+    Depends,
+    Form,
+    HTTPException,
+    Request,
+)
+from fastapi.responses import RedirectResponse
+from pydantic import EmailStr
+from starlette.responses import HTMLResponse
+
+from vibetuner.models import EmailVerificationTokenModel, UserModel
+from vibetuner.services.email import SESEmailService
+
+from ..email import send_magic_link_email
+from ..oauth import (
+    _create_auth_handler,
+    _create_auth_login_handler,
+    get_oauth_providers,
+)
+from ..templates import render_template
+from . import get_homepage_url
+
+
+def get_ses_service() -> SESEmailService:
+    return SESEmailService()
+
+
+def logout_user(request: Request):
+    request.session.pop("user", None)
+
+
+router = APIRouter(prefix="/auth")
+
+
+@router.get(
+    "/logout",
+    dependencies=[Depends(logout_user)],
+    response_class=RedirectResponse,
+    status_code=307,
+)
+async def auth_logout(request: Request):
+    return get_homepage_url(request)
+
+
+@router.get("/login", response_model=None)
+async def auth_login(
+    request: Request,
+    next: str | None = None,
+) -> RedirectResponse | HTMLResponse:
+    """Display unified login page with all available options"""
+    if request.user.is_authenticated:
+        # If user is already authenticated, redirect to homepage
+        return RedirectResponse(url=get_homepage_url(request), status_code=302)
+
+    oauth_providers = get_oauth_providers()
+    return render_template(
+        "login.html.jinja",
+        request=request,
+        ctx={
+            "providers": oauth_providers,
+            "next": next,
+            "has_oauth": bool(oauth_providers),
+            "has_email": True,
+        },
+    )
+
+
+@router.post("/magic-link-login", response_model=None)
+async def send_magic_link(
+    request: Request,
+    ses_service: Annotated[SESEmailService, Depends(get_ses_service)],
+    background_tasks: BackgroundTasks,
+    email: Annotated[EmailStr, Form()],
+    next: Annotated[str | None, Form()] = None,
+) -> HTMLResponse:
+    """Handle email magic link login form submission"""
+
+    # Create verification token
+    verification_token = await EmailVerificationTokenModel.create_token(email)
+
+    # Build login URL
+    login_url = request.url_for("email_verify", token=verification_token.token)
+    if next:
+        login_url = login_url.include_query_params(next=next)
+
+    background_tasks.add_task(
+        send_magic_link_email,
+        ses_service=ses_service,
+        lang=request.state.language,
+        to_address=email,
+        login_url=str(login_url),
+    )
+
+    return render_template(
+        "email_sent.html.jinja", request=request, ctx={"email": email, "next": next}
+    )
+
+
+@router.get(
+    "/email-verify/{token}",
+    response_class=RedirectResponse,
+    status_code=302,
+    response_model=None,
+)
+async def email_verify(
+    request: Request,
+    token: str,
+    next: str | None = None,
+) -> str:
+    """Verify email token and log in user"""
+    # Verify token
+    verification_token = await EmailVerificationTokenModel.verify_token(token)
+    if not verification_token:
+        raise HTTPException(status_code=400, detail="Invalid or expired token")
+
+    # Get or create user
+    user = await UserModel.get_by_email(verification_token.email)
+    if not user:
+        # Create new user
+        user = UserModel(
+            email=verification_token.email,
+            # Use email prefix as default name
+            name=verification_token.email.split("@")[0],
+        )
+        await user.insert()
+
+    # Set session
+    request.session["user"] = user.session_dict
+
+    # Redirect
+    return next or get_homepage_url(request)
+
+
+for provider in get_oauth_providers():
+    router.get(
+        f"/provider/{provider}",
+        response_class=RedirectResponse,
+        name=f"auth_with_{provider}",
+        response_model=None,
+    )(_create_auth_handler(provider))
+
+    router.get(
+        f"/login/provider/{provider}",
+        name=f"login_with_{provider}",
+        response_model=None,
+    )(_create_auth_login_handler(provider))

vibetuner/frontend/routes/debug.py

@@ -0,0 +1,414 @@
+from fastapi import (
+    APIRouter,
+    Depends,
+    HTTPException,
+    Request,
+    Response,
+)
+from fastapi.responses import (
+    HTMLResponse,
+    RedirectResponse,
+)
+
+from vibetuner.models import UserModel
+from vibetuner.models.registry import get_all_models
+
+from ..context import ctx
+from ..deps import MAGIC_COOKIE_NAME
+from ..templates import render_template
+
+
+def check_debug_access(request: Request, prod: str | None = None):
+    """Check if debug routes should be accessible."""
+    # Always allow in development mode
+    if ctx.DEBUG:
+        return True
+
+    # In production, require prod=1 parameter
+    if prod == "1":
+        return True
+
+    # Deny access
+    raise HTTPException(status_code=404, detail="Not found")
+
+
+router = APIRouter(prefix="/debug", dependencies=[Depends(check_debug_access)])
+
+
+@router.get("/", response_class=HTMLResponse)
+def debug_index(request: Request):
+    return render_template("debug/index.html.jinja", request)
+
+
+@router.get("/magic")
+def set_magic_cookie(response: Response):
+    """Set the magic access cookie."""
+    response = RedirectResponse(url="/", status_code=302)
+    response.set_cookie(
+        key=MAGIC_COOKIE_NAME,
+        value="granted",
+        httponly=True,
+        secure=not ctx.DEBUG,  # Only secure in production
+        samesite="lax",
+        max_age=86400 * 30,  # 30 days
+    )
+    return response
+
+
+@router.get("/no-magic")
+def remove_magic_cookie(response: Response):
+    """Remove the magic access cookie."""
+    response = RedirectResponse(url="/", status_code=302)
+    response.delete_cookie(key=MAGIC_COOKIE_NAME)
+    return response
+
+
+@router.get("/version", response_class=HTMLResponse)
+def debug_version(request: Request):
+    return render_template("debug/version.html.jinja", request)
+
+
+@router.get("/info", response_class=HTMLResponse)
+def debug_info(request: Request):
+    # Get cookies from request
+    cookies = dict(request.cookies)
+
+    # Get language from request state
+    language = getattr(request.state, "language", "Not set")
+
+    return render_template(
+        "debug/info.html.jinja", request, {"cookies": cookies, "language": language}
+    )
+
+
+def _extract_ref_name(ref: str) -> str:
+    """Extract type name from JSON schema $ref."""
+    return ref.split("/")[-1]
+
+
+def _parse_array_type(field_info: dict, field_name: str = "") -> str:
+    """Parse array field type from JSON schema."""
+    if "items" not in field_info:
+        return "array[object]"
+
+    items = field_info["items"]
+    items_type = items.get("type", "")
+
+    # Handle union types in arrays (anyOf, oneOf)
+    if "anyOf" in items:
+        union_types = _parse_union_types(items, "anyOf", field_name)
+        return f"array[{union_types}]"
+    elif "oneOf" in items:
+        union_types = _parse_union_types(items, "oneOf", field_name)
+        return f"array[{union_types}]"
+    # Handle object references
+    elif items_type == "object" and "$ref" in items:
+        ref_name = _extract_ref_name(items["$ref"])
+        return f"array[{ref_name}]"
+    elif "$ref" in items:
+        ref_name = _extract_ref_name(items["$ref"])
+        return f"array[{ref_name}]"
+    # Handle nested arrays
+    elif items_type == "array":
+        nested_array_type = _parse_array_type(items, field_name)
+        return f"array[{nested_array_type}]"
+    else:
+        return f"array[{items_type or 'object'}]"
+
+
+def _is_beanie_link_schema(option: dict) -> bool:
+    """Check if this schema represents a Beanie Link."""
+    if option.get("type") != "object":
+        return False
+
+    properties = option.get("properties", {})
+    required = option.get("required", [])
+
+    # Beanie Link has id and collection properties
+    return (
+        "id" in properties
+        and "collection" in properties
+        and "id" in required
+        and "collection" in required
+        and len(properties) == 2
+    )
+
+
+def _infer_link_target_from_field_name(field_name: str) -> str:
+    """Infer the target model type from field name patterns."""
+    # Common patterns for field names that reference other models
+    patterns = {
+        "oauth_accounts": "OAuthAccountModel",
+        "accounts": "AccountModel",
+        "users": "UserModel",
+        "user": "UserModel",
+        "stations": "StationModel",
+        "station": "StationModel",
+        "rundowns": "RundownModel",
+        "rundown": "RundownModel",
+        "fillers": "FillerModel",
+        "filler": "FillerModel",
+        "voices": "VoiceModel",
+        "voice": "VoiceModel",
+        "blobs": "BlobModel",
+        "blob": "BlobModel",
+    }
+
+    # Direct lookup
+    if field_name in patterns:
+        return patterns[field_name]
+
+    # Try singular/plural conversions
+    if field_name.endswith("s"):
+        singular = field_name[:-1]
+        if singular in patterns:
+            return patterns[singular]
+
+    # Pattern-based inference (field_name -> FieldNameModel)
+    if "_" in field_name:
+        # Convert snake_case to PascalCase
+        parts = field_name.split("_")
+        model_name = "".join(word.capitalize() for word in parts) + "Model"
+        return model_name
+    else:
+        # Simple case: field_name -> FieldNameModel
+        return field_name.capitalize() + "Model"
+
+
+def _process_union_option(option: dict) -> tuple[str | None, bool]:
+    """Process a single union option, return (type_name, is_link)."""
+    if "type" in option:
+        if _is_beanie_link_schema(option):
+            return None, True
+        else:
+            return option["type"], False
+    elif "$ref" in option:
+        ref_name = _extract_ref_name(option["$ref"])
+        return ref_name, False
+    elif "const" in option:
+        return f"'{option['const']}'", False
+    else:
+        if option.get("type") == "object" and option.get("additionalProperties"):
+            return None, False  # Skip generic objects from Links
+        return "object", False
+
+
+def _parse_union_types(field_info: dict, union_key: str, field_name: str = "") -> str:
+    """Parse union types (anyOf, oneOf) from JSON schema."""
+    types = []
+    has_link = False
+
+    for option in field_info[union_key]:
+        type_name, is_link = _process_union_option(option)
+        if is_link:
+            has_link = True
+        elif type_name:
+            types.append(type_name)
+
+    if not types:
+        return union_key
+
+    # Add Link indicator with inferred target type
+    if has_link:
+        if field_name:
+            target_type = _infer_link_target_from_field_name(field_name)
+            return f"Link[{target_type}]"
+        else:
+            return f"Link[{types[0] if types else 'object'}]"
+
+    # If we have many types, show count to keep display clean
+    if len(types) > 4:
+        return f"{len(types)} types"
+
+    return " | ".join(types)
+
+
+def _handle_fallback_type(field_info: dict, field_name: str) -> str:
+    """Handle fallback type inference when no explicit type is provided."""
+    if "properties" in field_info:
+        return "object"
+    elif "items" in field_info:
+        return "array"
+    elif "format" in field_info:
+        return field_info["format"]
+    else:
+        return field_name.split("_")[-1] if "_" in field_name else "any"
+
+
+def _parse_field_type(field_info: dict, field_name: str) -> str:
+    """Parse field type from JSON schema field info."""
+    field_type = field_info.get("type", "")
+
+    # Handle array types
+    if field_type == "array":
+        return _parse_array_type(field_info, field_name)
+
+    # Handle object references
+    if "$ref" in field_info:
+        return _extract_ref_name(field_info["$ref"])
+
+    # Handle union types
+    if "anyOf" in field_info:
+        return _parse_union_types(field_info, "anyOf", field_name)
+
+    if "oneOf" in field_info:
+        return _parse_union_types(field_info, "oneOf", field_name)
+
+    # Handle inheritance
+    if "allOf" in field_info:
+        return "object"
+
+    # Handle const values
+    if "const" in field_info:
+        return f"const({field_info['const']})"
+
+    # Handle enum values
+    if "enum" in field_info:
+        return f"enum({len(field_info['enum'])} values)"
+
+    # Fallback type inference
+    if not field_type:
+        return _handle_fallback_type(field_info, field_name)
+
+    return field_type
+
+
+def _get_extra_field_info(field_info: dict) -> dict:
+    """Extract additional field metadata."""
+    extra = {}
+
+    # Add constraints if present
+    if "minimum" in field_info:
+        extra["min"] = field_info["minimum"]
+    if "maximum" in field_info:
+        extra["max"] = field_info["maximum"]
+    if "minLength" in field_info:
+        extra["min_length"] = field_info["minLength"]
+    if "maxLength" in field_info:
+        extra["max_length"] = field_info["maxLength"]
+    if "pattern" in field_info:
+        extra["pattern"] = field_info["pattern"]
+    if "format" in field_info:
+        extra["format"] = field_info["format"]
+    if "default" in field_info:
+        extra["default"] = field_info["default"]
+    if "enum" in field_info:
+        enum_values = field_info["enum"]
+        if len(enum_values) <= 5:
+            extra["enum"] = enum_values
+        else:
+            extra["enum_count"] = len(enum_values)
+
+    return extra
+
+
+def _extract_fields_from_schema(schema: dict) -> list[dict]:
+    """Extract field information from JSON schema."""
+    fields: list[dict] = []
+
+    if "properties" not in schema:
+        return fields
+
+    for field_name, field_info in schema["properties"].items():
+        field_type = _parse_field_type(field_info, field_name)
+        field_description = field_info.get("description", "")
+        required = field_name in schema.get("required", [])
+        extra_info = _get_extra_field_info(field_info)
+
+        fields.append(
+            {
+                "name": field_name,
+                "type": field_type,
+                "required": required,
+                "description": field_description,
+                "extra": extra_info,
+            }
+        )
+
+    return fields
+
+
+def _get_collection_info(model) -> dict:
+    """Extract collection information from a Beanie model."""
+    if hasattr(model, "Settings") and hasattr(model.Settings, "name"):
+        collection_name = model.Settings.name
+    else:
+        collection_name = model.__name__.lower()
+
+    schema = model.model_json_schema()
+    fields = _extract_fields_from_schema(schema)
+
+    return {
+        "name": collection_name,
+        "model_name": model.__name__,
+        "fields": fields,
+        "total_fields": len(fields),
+    }
+
+
+@router.get("/collections", response_class=HTMLResponse)
+def debug_collections(request: Request):
+    """Debug endpoint to display MongoDB collection schemas."""
+    collections_info = [_get_collection_info(model) for model in get_all_models()]
+
+    return render_template(
+        "debug/collections.html.jinja", request, {"collections": collections_info}
+    )
+
+
+@router.get("/users", response_class=HTMLResponse)
+async def debug_users(request: Request):
+    """Debug endpoint to list and impersonate users."""
+
+    users = await UserModel.find_all().to_list()
+    current_user_id = (
+        request.session.get("user", {}).get("id")
+        if isinstance(request.session.get("user"), dict)
+        else request.session.get("user")
+    )
+
+    return render_template(
+        "debug/users.html.jinja",
+        request,
+        {"users": users, "current_user_id": current_user_id},
+    )
+
+
+@router.post("/impersonate/{user_id}")
+async def debug_impersonate_user(request: Request, user_id: str):
+    """Impersonate a user by setting their ID in the session."""
+    # Double check debug mode for security
+    if not ctx.DEBUG:
+        raise HTTPException(status_code=404, detail="Not found")
+
+    # Verify user exists
+    user = await UserModel.get(user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    # Set full user session data (using the proper session_dict method)
+    request.session["user"] = user.session_dict
+
+    return RedirectResponse(url="/", status_code=302)
+
+
+@router.post("/stop-impersonation")
+async def debug_stop_impersonation(request: Request):
+    """Stop impersonating and clear user session."""
+    # Double check debug mode for security
+    if not ctx.DEBUG:
+        raise HTTPException(status_code=404, detail="Not found")
+
+    request.session.pop("user", None)
+    return RedirectResponse(url="/debug/users", status_code=302)
+
+
+@router.get("/clear-session")
+async def debug_clear_session(request: Request):
+    """Clear all session data to fix corrupted sessions."""
+    # Double check debug mode for security
+    if not ctx.DEBUG:
+        raise HTTPException(status_code=404, detail="Not found")
+
+    request.session.clear()
+    return RedirectResponse(url="/debug/users?cleared=1", status_code=302)

vibetuner/frontend/routes/health.py

@@ -0,0 +1,33 @@
+import os
+from datetime import datetime
+
+from fastapi import APIRouter
+
+from vibetuner.config import settings
+from vibetuner.paths import root as root_path
+
+
+router = APIRouter(prefix="/health")
+
+# Store startup time for instance identification
+_startup_time = datetime.now()
+
+
+@router.get("/ping")
+def health_ping():
+    """Simple health check endpoint"""
+    return {"ping": "ok"}
+
+
+@router.get("/id")
+def health_instance_id():
+    """Instance identification endpoint for distinguishing app instances"""
+    return {
+        "app": settings.project.project_slug,
+        "port": int(os.environ.get("PORT", 8000)),
+        "debug": settings.debug,
+        "status": "healthy",
+        "root_path": str(root_path.resolve()),
+        "process_id": os.getpid(),
+        "startup_time": _startup_time.isoformat(),
+    }

vibetuner/frontend/routes/language.py

@@ -0,0 +1,43 @@
+from babel import Locale
+from fastapi import APIRouter, Depends, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+
+from ..deps import require_htmx
+from ..lifespan import ctx
+from ..templates import render_template
+
+
+router = APIRouter()
+
+LOCALE_NAMES: dict[str, str] = dict(
+    sorted(
+        {
+            locale: (Locale.parse(locale).display_name or locale).capitalize()
+            for locale in ctx.supported_languages
+        }.items(),
+        key=lambda x: x[1],
+    ),
+)
+
+
+@router.get("/set-language/{lang}")
+async def set_language(request: Request, lang: str, current: str) -> RedirectResponse:
+    new_url = f"/{lang}{current[3:]}" if current else request.url_for("homepage").path
+    response = RedirectResponse(url=new_url)
+    response.set_cookie(key="language", value=lang, max_age=3600)
+
+    return response
+
+
+@router.get("/get-languages", dependencies=[Depends(require_htmx)])
+async def get_languages(request: Request) -> HTMLResponse:
+    """Return a list of supported languages."""
+
+    return render_template(
+        "lang/select.html.jinja",
+        request=request,
+        ctx={
+            "locale_names": LOCALE_NAMES,
+            "current_language": request.state.language,
+        },
+    )

vibetuner/frontend/routes/meta.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from fastapi.responses import FileResponse, HTMLResponse, PlainTextResponse
+
+from vibetuner.paths import fallback_static_default
+
+from ..templates import render_template
+
+
+router = APIRouter()
+
+
+# Favicon Related Routes
+# Todo, provide an easy way to override default statics
+@router.get("/favicon.ico", response_class=FileResponse)
+async def favicon() -> Path:
+    return fallback_static_default("favicons", "favicon.ico")
+
+
+# Misc static routes
+@router.get("/robots.txt", response_class=PlainTextResponse)
+def robots(request: Request) -> HTMLResponse:
+    return render_template(
+        "meta/robots.txt.jinja",
+        request=request,
+        media_type="text/plain",
+    )
+
+
+@router.get("/sitemap.xml")
+async def sitemap(request: Request) -> HTMLResponse:
+    return render_template(
+        "meta/sitemap.xml.jinja",
+        request,
+        media_type="application/xml",
+    )
+
+
+@router.get("/site.webmanifest")
+async def site_webmanifest(request: Request) -> HTMLResponse:
+    return render_template(
+        "meta/site.webmanifest.jinja",
+        request,
+        media_type="application/manifest+json",
+    )
+
+
+@router.get("/browserconfig.xml")
+async def browserconfig(request: Request) -> HTMLResponse:
+    return render_template(
+        "meta/browserconfig.xml.jinja",
+        request,
+        media_type="application/xml",
+    )