kairo-code 0.1.0__py3-none-any.whl

kairo/backend/services/admin/audit_service.py

@@ -0,0 +1,78 @@
+import logging
+from datetime import datetime
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.models.audit_log import AuditLog
+
+logger = logging.getLogger(__name__)
+
+
+class AuditService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def log(
+        self,
+        admin_user_id: str,
+        action: str,
+        target_type: str,
+        target_id: str | None = None,
+        details: dict | None = None,
+        result: str = "success",
+        ip_address: str | None = None,
+        user_agent: str | None = None,
+        session_id: str | None = None,
+    ) -> AuditLog:
+        entry = AuditLog(
+            admin_user_id=admin_user_id,
+            action=action,
+            target_type=target_type,
+            target_id=target_id,
+            details=details,
+            result=result,
+            ip_address=ip_address,
+            user_agent=user_agent,
+            session_id=session_id,
+        )
+        self.db.add(entry)
+        await self.db.commit()
+        await self.db.refresh(entry)
+        logger.info(
+            "Audit: admin=%s action=%s target=%s/%s result=%s",
+            admin_user_id, action, target_type, target_id, result,
+        )
+        return entry
+
+    async def list_logs(
+        self,
+        filters: dict | None = None,
+        cursor: str | None = None,
+        limit: int = 50,
+    ) -> list[AuditLog]:
+        stmt = select(AuditLog).order_by(AuditLog.created_at.desc())
+
+        if filters:
+            if filters.get("admin_id"):
+                stmt = stmt.where(AuditLog.admin_user_id == filters["admin_id"])
+            if filters.get("action"):
+                stmt = stmt.where(AuditLog.action == filters["action"])
+            if filters.get("target_type"):
+                stmt = stmt.where(AuditLog.target_type == filters["target_type"])
+            if filters.get("result"):
+                stmt = stmt.where(AuditLog.result == filters["result"])
+            if filters.get("date_from"):
+                stmt = stmt.where(AuditLog.created_at >= filters["date_from"])
+            if filters.get("date_to"):
+                stmt = stmt.where(AuditLog.created_at <= filters["date_to"])
+
+        if cursor:
+            # Cursor is the id of the last item seen; fetch older entries
+            cursor_log = await self.db.get(AuditLog, cursor)
+            if cursor_log:
+                stmt = stmt.where(AuditLog.created_at < cursor_log.created_at)
+
+        stmt = stmt.limit(limit)
+        result = await self.db.execute(stmt)
+        return list(result.scalars().all())

kairo/backend/services/admin/content_service.py

@@ -0,0 +1,119 @@
+import logging
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from backend.models.conversation import Conversation, Message
+from backend.models.image_generation import ImageGeneration
+
+logger = logging.getLogger(__name__)
+
+
+class AdminContentService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def list_conversations(
+        self,
+        search: str | None = None,
+        user_id: str | None = None,
+        cursor: str | None = None,
+        limit: int = 50,
+    ) -> list[dict]:
+        stmt = select(
+            Conversation,
+            func.count(Message.id).label("message_count"),
+        ).outerjoin(Message).group_by(Conversation.id).order_by(Conversation.updated_at.desc())
+
+        if search:
+            stmt = stmt.where(Conversation.title.ilike(f"%{search}%"))
+        if user_id:
+            stmt = stmt.where(Conversation.user_id == user_id)
+
+        if cursor:
+            cursor_conv = await self.db.get(Conversation, cursor)
+            if cursor_conv:
+                stmt = stmt.where(Conversation.updated_at < cursor_conv.updated_at)
+
+        stmt = stmt.limit(limit)
+        result = await self.db.execute(stmt)
+        rows = result.all()
+        return [
+            {
+                "id": conv.id,
+                "title": conv.title,
+                "model": conv.model,
+                "user_id": conv.user_id,
+                "message_count": msg_count,
+                "created_at": conv.created_at,
+                "updated_at": conv.updated_at,
+            }
+            for conv, msg_count in rows
+        ]
+
+    async def get_conversation_detail(self, conversation_id: str) -> dict | None:
+        stmt = (
+            select(Conversation)
+            .options(selectinload(Conversation.messages))
+            .where(Conversation.id == conversation_id)
+        )
+        result = await self.db.execute(stmt)
+        conv = result.scalar_one_or_none()
+        if not conv:
+            return None
+        return {
+            "id": conv.id,
+            "title": conv.title,
+            "model": conv.model,
+            "user_id": conv.user_id,
+            "created_at": conv.created_at,
+            "updated_at": conv.updated_at,
+            "messages": [
+                {
+                    "id": m.id,
+                    "role": m.role,
+                    "content": m.content,
+                    "image_url": m.image_url,
+                    "created_at": m.created_at,
+                }
+                for m in conv.messages
+            ],
+        }
+
+    async def delete_conversation(self, conversation_id: str) -> bool:
+        conv = await self.db.get(Conversation, conversation_id)
+        if not conv:
+            return False
+        await self.db.delete(conv)
+        await self.db.commit()
+        logger.info("Conversation %s deleted", conversation_id)
+        return True
+
+    async def list_recent_images(
+        self,
+        user_id: str | None = None,
+        cursor: str | None = None,
+        limit: int = 50,
+    ) -> list[ImageGeneration]:
+        stmt = select(ImageGeneration).order_by(ImageGeneration.created_at.desc())
+
+        if user_id:
+            stmt = stmt.where(ImageGeneration.user_id == user_id)
+        if cursor:
+            cursor_img = await self.db.get(ImageGeneration, cursor)
+            if cursor_img:
+                stmt = stmt.where(ImageGeneration.created_at < cursor_img.created_at)
+
+        stmt = stmt.limit(limit)
+        result = await self.db.execute(stmt)
+        return list(result.scalars().all())
+
+    async def delete_image(self, image_id: str) -> bool:
+        img = await self.db.get(ImageGeneration, image_id)
+        if not img:
+            return False
+        await self.db.delete(img)
+        await self.db.commit()
+        logger.info("Image %s deleted", image_id)
+        return True

kairo/backend/services/admin/incident_service.py

@@ -0,0 +1,94 @@
+import logging
+import uuid
+from datetime import datetime, UTC
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.models.incident import Incident
+
+logger = logging.getLogger(__name__)
+
+
+class IncidentService:
+    """Admin service for CRUD operations on incidents."""
+
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def create_incident(
+        self,
+        title: str,
+        component: str,
+        description: str | None = None,
+        severity: str = "warning",
+    ) -> Incident:
+        """Create a new incident."""
+        incident = Incident(
+            id=str(uuid.uuid4()),
+            title=title,
+            description=description,
+            severity=severity,
+            component=component,
+            status="investigating",
+            started_at=datetime.now(UTC),
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        )
+        self.db.add(incident)
+        await self.db.commit()
+        await self.db.refresh(incident)
+        logger.info("Incident created: id=%s title=%s component=%s severity=%s", incident.id, title, component, severity)
+        return incident
+
+    async def update_incident(self, incident_id: str, **kwargs) -> Incident | None:
+        """Update an existing incident's fields."""
+        incident = await self.get_incident(incident_id)
+        if not incident:
+            return None
+
+        allowed_fields = {"title", "description", "severity", "status", "resolved_at"}
+        for key, value in kwargs.items():
+            if key in allowed_fields and value is not None:
+                setattr(incident, key, value)
+
+        # Auto-set resolved_at when status changes to resolved
+        if kwargs.get("status") == "resolved" and not incident.resolved_at:
+            incident.resolved_at = datetime.now(UTC)
+
+        incident.updated_at = datetime.now(UTC)
+        await self.db.commit()
+        await self.db.refresh(incident)
+        logger.info("Incident updated: id=%s fields=%s", incident_id, list(kwargs.keys()))
+        return incident
+
+    async def resolve_incident(self, incident_id: str) -> Incident | None:
+        """Mark an incident as resolved."""
+        incident = await self.get_incident(incident_id)
+        if not incident:
+            return None
+
+        incident.status = "resolved"
+        incident.resolved_at = datetime.now(UTC)
+        incident.updated_at = datetime.now(UTC)
+        await self.db.commit()
+        await self.db.refresh(incident)
+        logger.info("Incident resolved: id=%s", incident_id)
+        return incident
+
+    async def list_incidents(
+        self, limit: int = 50, include_resolved: bool = False
+    ) -> list[Incident]:
+        """List incidents, optionally including resolved ones."""
+        stmt = select(Incident).order_by(Incident.started_at.desc())
+        if not include_resolved:
+            stmt = stmt.where(Incident.status != "resolved")
+        stmt = stmt.limit(limit)
+        result = await self.db.execute(stmt)
+        return list(result.scalars().all())
+
+    async def get_incident(self, incident_id: str) -> Incident | None:
+        """Get a single incident by ID."""
+        stmt = select(Incident).where(Incident.id == incident_id)
+        result = await self.db.execute(stmt)
+        return result.scalar_one_or_none()

kairo/backend/services/admin/stats_service.py

@@ -0,0 +1,281 @@
+import logging
+from datetime import date, datetime, timedelta, timezone
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.models.conversation import Conversation
+from backend.models.image_generation import ImageGeneration
+from backend.models.usage import UsageRecord
+from backend.models.user import User
+
+logger = logging.getLogger(__name__)
+
+
+def _fill_daily_counts(
+    rows: list[tuple], days: int, value_key: str = "count"
+) -> list[dict]:
+    """Fill gaps so every date in the range has an entry (zero if missing).
+
+    ``rows`` must be an iterable of objects with ``.date`` and a numeric
+    attribute whose name matches *value_key*.  Returns a list of dicts
+    sorted by date ascending with keys ``date`` (str) and *value_key*.
+    """
+    today = date.today()
+    start = today - timedelta(days=days - 1)
+
+    lookup: dict[str, int] = {}
+    for r in rows:
+        # r.date may already be a date object or a string
+        d = str(r.date) if not isinstance(r.date, str) else r.date
+        lookup[d] = getattr(r, value_key, 0) or 0
+
+    result: list[dict] = []
+    current = start
+    while current <= today:
+        key = current.isoformat()
+        result.append({"date": key, value_key: lookup.get(key, 0)})
+        current += timedelta(days=1)
+    return result
+
+
+class AdminStatsService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get_overview(self) -> dict:
+        now = datetime.now(timezone.utc)
+        start_of_day = now.replace(hour=0, minute=0, second=0, microsecond=0)
+
+        # Total users
+        total_result = await self.db.execute(select(func.count(User.id)))
+        total_users = total_result.scalar() or 0
+
+        # Active users by time window (users with usage records)
+        active_today = await self._count_active_users(start_of_day)
+        active_7d = await self._count_active_users(now - timedelta(days=7))
+        active_30d = await self._count_active_users(now - timedelta(days=30))
+
+        # Plan counts
+        pro_result = await self.db.execute(
+            select(func.count(User.id)).where(User.plan == "pro")
+        )
+        pro_subscribers = pro_result.scalar() or 0
+
+        max_result = await self.db.execute(
+            select(func.count(User.id)).where(User.plan == "max")
+        )
+        max_subscribers = max_result.scalar() or 0
+
+        # Estimated MRR (Pro=$20, Max=$50)
+        mrr = (pro_subscribers * 20) + (max_subscribers * 50)
+
+        # Conversations created today
+        conv_result = await self.db.execute(
+            select(func.count(Conversation.id)).where(Conversation.created_at >= start_of_day)
+        )
+        conversations_today = conv_result.scalar() or 0
+
+        # Images generated today
+        img_result = await self.db.execute(
+            select(func.count(ImageGeneration.id)).where(ImageGeneration.created_at >= start_of_day)
+        )
+        images_today = img_result.scalar() or 0
+
+        return {
+            "total_users": total_users,
+            "active_today": active_today,
+            "active_7d": active_7d,
+            "active_30d": active_30d,
+            "pro_subscribers": pro_subscribers,
+            "max_subscribers": max_subscribers,
+            "mrr": mrr,
+            "conversations_today": conversations_today,
+            "images_today": images_today,
+        }
+
+    async def _count_active_users(self, since: datetime) -> int:
+        result = await self.db.execute(
+            select(func.count(func.distinct(UsageRecord.user_id))).where(
+                UsageRecord.created_at >= since
+            )
+        )
+        return result.scalar() or 0
+
+    async def get_user_growth(self, days: int = 30) -> list[dict]:
+        since = datetime.now(timezone.utc) - timedelta(days=days)
+        stmt = (
+            select(
+                func.date(User.created_at).label("date"),
+                func.count(User.id).label("signups"),
+            )
+            .where(User.created_at >= since)
+            .group_by(func.date(User.created_at))
+            .order_by(func.date(User.created_at))
+        )
+        result = await self.db.execute(stmt)
+        return [{"date": str(r.date), "signups": r.signups} for r in result.all()]
+
+    async def get_usage_stats(self, days: int = 30) -> list[dict]:
+        since = datetime.now(timezone.utc) - timedelta(days=days)
+        stmt = (
+            select(
+                func.date(UsageRecord.created_at).label("date"),
+                func.sum(UsageRecord.prompt_tokens + UsageRecord.completion_tokens).label("total_tokens"),
+            )
+            .where(UsageRecord.created_at >= since)
+            .group_by(func.date(UsageRecord.created_at))
+            .order_by(func.date(UsageRecord.created_at))
+        )
+        result = await self.db.execute(stmt)
+        return [{"date": str(r.date), "total_tokens": r.total_tokens or 0} for r in result.all()]
+
+    async def get_revenue_stats(self) -> dict:
+        free_result = await self.db.execute(
+            select(func.count(User.id)).where(User.plan == "free")
+        )
+        pro_result = await self.db.execute(
+            select(func.count(User.id)).where(User.plan == "pro")
+        )
+        max_result = await self.db.execute(
+            select(func.count(User.id)).where(User.plan == "max")
+        )
+        return {
+            "free_count": free_result.scalar() or 0,
+            "pro_count": pro_result.scalar() or 0,
+            "max_count": max_result.scalar() or 0,
+        }
+
+    async def get_top_users(self, limit: int = 20) -> list[dict]:
+        stmt = (
+            select(
+                UsageRecord.user_id,
+                User.email,
+                func.sum(UsageRecord.prompt_tokens + UsageRecord.completion_tokens).label("total_tokens"),
+            )
+            .join(User, UsageRecord.user_id == User.id)
+            .group_by(UsageRecord.user_id, User.email)
+            .order_by(func.sum(UsageRecord.prompt_tokens + UsageRecord.completion_tokens).desc())
+            .limit(limit)
+        )
+        result = await self.db.execute(stmt)
+        return [
+            {"user_id": r.user_id, "email": r.email, "total_tokens": r.total_tokens or 0}
+            for r in result.all()
+        ]
+
+    # ------------------------------------------------------------------ #
+    #  Analytics endpoints                                                #
+    # ------------------------------------------------------------------ #
+
+    async def get_daily_signups(self, days: int = 30) -> list[dict]:
+        """Daily signup counts for the past *days* days, zero-filled."""
+        since = datetime.now(timezone.utc) - timedelta(days=days - 1)
+        stmt = (
+            select(
+                func.date(User.created_at).label("date"),
+                func.count(User.id).label("count"),
+            )
+            .where(User.created_at >= since)
+            .group_by(func.date(User.created_at))
+            .order_by(func.date(User.created_at))
+        )
+        result = await self.db.execute(stmt)
+        return _fill_daily_counts(result.all(), days, "count")
+
+    async def get_daily_active_users(self, days: int = 30) -> list[dict]:
+        """Daily active user counts (distinct users with usage records)."""
+        since = datetime.now(timezone.utc) - timedelta(days=days - 1)
+        stmt = (
+            select(
+                func.date(UsageRecord.created_at).label("date"),
+                func.count(func.distinct(UsageRecord.user_id)).label("count"),
+            )
+            .where(UsageRecord.created_at >= since)
+            .group_by(func.date(UsageRecord.created_at))
+            .order_by(func.date(UsageRecord.created_at))
+        )
+        result = await self.db.execute(stmt)
+        return _fill_daily_counts(result.all(), days, "count")
+
+    async def get_usage_over_time(self, days: int = 30) -> list[dict]:
+        """Daily total tokens (prompt + completion) for the past *days* days."""
+        since = datetime.now(timezone.utc) - timedelta(days=days - 1)
+        stmt = (
+            select(
+                func.date(UsageRecord.created_at).label("date"),
+                func.sum(
+                    UsageRecord.prompt_tokens + UsageRecord.completion_tokens
+                ).label("tokens"),
+            )
+            .where(UsageRecord.created_at >= since)
+            .group_by(func.date(UsageRecord.created_at))
+            .order_by(func.date(UsageRecord.created_at))
+        )
+        result = await self.db.execute(stmt)
+        return _fill_daily_counts(result.all(), days, "tokens")
+
+    async def get_plan_distribution(self) -> list[dict]:
+        """Current count of users grouped by plan."""
+        stmt = (
+            select(
+                User.plan.label("plan"),
+                func.count(User.id).label("count"),
+            )
+            .group_by(User.plan)
+            .order_by(func.count(User.id).desc())
+        )
+        result = await self.db.execute(stmt)
+        return [{"plan": r.plan, "count": r.count} for r in result.all()]
+
+    async def get_top_users_analytics(self, limit: int = 20) -> list[dict]:
+        """Top N users by total token usage with conversation and image counts.
+
+        Uses correlated scalar sub-selects for conversations and images to
+        avoid row multiplication from multiple JOINs.
+        """
+        # Subquery: conversation count per user
+        conv_sub = (
+            select(func.count(Conversation.id))
+            .where(Conversation.user_id == UsageRecord.user_id)
+            .correlate(UsageRecord)
+            .scalar_subquery()
+        )
+        # Subquery: image generation count per user
+        img_sub = (
+            select(func.count(ImageGeneration.id))
+            .where(ImageGeneration.user_id == UsageRecord.user_id)
+            .correlate(UsageRecord)
+            .scalar_subquery()
+        )
+
+        stmt = (
+            select(
+                User.email,
+                User.plan,
+                func.sum(
+                    UsageRecord.prompt_tokens + UsageRecord.completion_tokens
+                ).label("total_tokens"),
+                conv_sub.label("conversations"),
+                img_sub.label("images"),
+            )
+            .join(User, UsageRecord.user_id == User.id)
+            .group_by(UsageRecord.user_id, User.email, User.plan)
+            .order_by(
+                func.sum(
+                    UsageRecord.prompt_tokens + UsageRecord.completion_tokens
+                ).desc()
+            )
+            .limit(limit)
+        )
+        result = await self.db.execute(stmt)
+        return [
+            {
+                "email": r.email,
+                "plan": r.plan,
+                "total_tokens": r.total_tokens or 0,
+                "conversations": r.conversations or 0,
+                "images": r.images or 0,
+            }
+            for r in result.all()
+        ]

kairo/backend/services/admin/system_service.py

@@ -0,0 +1,126 @@
+import logging
+import time
+from datetime import datetime, timezone
+
+import httpx
+from sqlalchemy import select, text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.config import settings
+from backend.models.feature_flag import FeatureFlag
+
+logger = logging.getLogger(__name__)
+
+
+class AdminSystemService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get_health(self) -> dict:
+        services = []
+
+        # Database check
+        try:
+            t0 = time.monotonic()
+            await self.db.execute(text("SELECT 1"))
+            latency = int((time.monotonic() - t0) * 1000)
+            services.append({"name": "Database", "status": "healthy", "latency_ms": latency})
+        except Exception as e:
+            services.append({"name": "Database", "status": "down", "message": str(e)[:100]})
+
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            # vLLM check
+            try:
+                t0 = time.monotonic()
+                resp = await client.get(f"{settings.VLLM_BASE_URL}/health")
+                latency = int((time.monotonic() - t0) * 1000)
+                status = "healthy" if resp.status_code == 200 else "degraded"
+                services.append({"name": "vLLM", "status": status, "latency_ms": latency})
+            except Exception:
+                services.append({"name": "vLLM", "status": "down", "message": "Connection failed"})
+
+            # vLLM Lite check
+            if settings.VLLM_LITE_BASE_URL:
+                try:
+                    t0 = time.monotonic()
+                    resp = await client.get(f"{settings.VLLM_LITE_BASE_URL}/health")
+                    latency = int((time.monotonic() - t0) * 1000)
+                    status = "healthy" if resp.status_code == 200 else "degraded"
+                    services.append({"name": "vLLM Lite", "status": status, "latency_ms": latency})
+                except Exception:
+                    services.append({"name": "vLLM Lite", "status": "down", "message": "Connection failed"})
+
+            # FLUX check
+            if settings.FLUX_BASE_URL:
+                try:
+                    t0 = time.monotonic()
+                    resp = await client.get(f"{settings.FLUX_BASE_URL}/health")
+                    latency = int((time.monotonic() - t0) * 1000)
+                    status = "healthy" if resp.status_code == 200 else "degraded"
+                    services.append({"name": "FLUX Image", "status": status, "latency_ms": latency})
+                except Exception:
+                    services.append({"name": "FLUX Image", "status": "down", "message": "Connection failed"})
+
+        # Determine overall status
+        statuses = [s["status"] for s in services]
+        if all(s == "healthy" for s in statuses):
+            overall = "healthy"
+        elif any(s == "down" for s in statuses):
+            overall = "degraded"
+        else:
+            overall = "degraded"
+
+        return {
+            "overall": overall,
+            "services": services,
+            "checked_at": datetime.now(timezone.utc).isoformat(),
+        }
+
+    async def get_feature_flags(self) -> list[FeatureFlag]:
+        stmt = select(FeatureFlag).order_by(FeatureFlag.key)
+        result = await self.db.execute(stmt)
+        return list(result.scalars().all())
+
+    async def toggle_feature_flag(
+        self, key: str, enabled: bool, admin_user_id: str
+    ) -> FeatureFlag | None:
+        stmt = select(FeatureFlag).where(FeatureFlag.key == key)
+        result = await self.db.execute(stmt)
+        flag = result.scalar_one_or_none()
+        if not flag:
+            return None
+        flag.enabled = enabled
+        flag.updated_by = admin_user_id
+        flag.updated_at = datetime.now(timezone.utc)
+        await self.db.commit()
+        await self.db.refresh(flag)
+        logger.info("Feature flag %s set to %s by %s", key, enabled, admin_user_id)
+        return flag
+
+    async def get_config(self) -> list[dict]:
+        """Return allowlisted non-secret config values."""
+        allowlist = [
+            "VLLM_BASE_URL",
+            "VLLM_LITE_BASE_URL",
+            "HOST",
+            "PORT",
+            "LOG_LEVEL",
+            "JWT_EXPIRE_HOURS",
+            "DEFAULT_DAILY_TOKEN_LIMIT",
+            "DEFAULT_MONTHLY_TOKEN_LIMIT",
+            "PRO_DAILY_TOKEN_LIMIT",
+            "PRO_MONTHLY_TOKEN_LIMIT",
+            "MAX_DAILY_TOKEN_LIMIT",
+            "MAX_MONTHLY_TOKEN_LIMIT",
+            "PRO_DAILY_IMAGE_LIMIT",
+            "PRO_MONTHLY_IMAGE_LIMIT",
+            "MAX_DAILY_IMAGE_LIMIT",
+            "MAX_MONTHLY_IMAGE_LIMIT",
+            "AGENT_OFFLINE_THRESHOLD_SECONDS",
+            "S3_IMAGES_REGION",
+        ]
+        entries = []
+        for key in allowlist:
+            if hasattr(settings, key):
+                entries.append({"key": key, "value": str(getattr(settings, key))})
+        return entries