kairo-code 0.1.0__py3-none-any.whl

kairo/backend/services/admin/user_service.py

@@ -0,0 +1,157 @@
+import logging
+from datetime import datetime, timezone
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.models.api_key import ApiKey
+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__)
+
+
+class AdminUserService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def list_users(
+        self,
+        search: str | None = None,
+        plan: str | None = None,
+        status: str | None = None,
+        cursor: str | None = None,
+        limit: int = 50,
+    ) -> list[User]:
+        stmt = select(User).order_by(User.created_at.desc())
+
+        if search:
+            stmt = stmt.where(User.email.ilike(f"%{search}%"))
+        if plan:
+            stmt = stmt.where(User.plan == plan)
+        if status:
+            stmt = stmt.where(User.status == status)
+
+        if cursor:
+            cursor_user = await self.db.get(User, cursor)
+            if cursor_user:
+                stmt = stmt.where(User.created_at < cursor_user.created_at)
+
+        stmt = stmt.limit(limit)
+        result = await self.db.execute(stmt)
+        return list(result.scalars().all())
+
+    async def get_user_detail(self, user_id: str) -> User | None:
+        return await self.db.get(User, user_id)
+
+    async def change_plan(self, user_id: str, new_plan: str) -> User | None:
+        user = await self.db.get(User, user_id)
+        if not user:
+            return None
+        user.plan = new_plan
+        await self.db.commit()
+        await self.db.refresh(user)
+        logger.info("User %s plan changed to %s", user_id, new_plan)
+        return user
+
+    async def change_status(self, user_id: str, new_status: str) -> User | None:
+        user = await self.db.get(User, user_id)
+        if not user:
+            return None
+        user.status = new_status
+        await self.db.commit()
+        await self.db.refresh(user)
+        logger.info("User %s status changed to %s", user_id, new_status)
+        return user
+
+    async def change_role(self, user_id: str, new_role: str) -> User | None:
+        user = await self.db.get(User, user_id)
+        if not user:
+            return None
+        user.role = new_role
+        await self.db.commit()
+        await self.db.refresh(user)
+        logger.info("User %s role changed to %s", user_id, new_role)
+        return user
+
+    async def get_user_usage(self, user_id: str) -> list[dict]:
+        now = datetime.now(timezone.utc)
+        start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        # Daily usage for the past 30 days
+        from datetime import timedelta
+
+        start_30d = now - timedelta(days=30)
+        stmt = (
+            select(
+                func.date(UsageRecord.created_at).label("date"),
+                func.sum(UsageRecord.prompt_tokens + UsageRecord.completion_tokens).label("total_tokens"),
+            )
+            .where(UsageRecord.user_id == user_id)
+            .where(UsageRecord.created_at >= start_30d)
+            .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_user_conversations(
+        self,
+        user_id: str,
+        cursor: str | None = None,
+        limit: int = 50,
+    ) -> list[Conversation]:
+        stmt = (
+            select(Conversation)
+            .where(Conversation.user_id == user_id)
+            .order_by(Conversation.updated_at.desc())
+        )
+        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)
+        return list(result.scalars().all())
+
+    async def get_user_images(
+        self,
+        user_id: str,
+        cursor: str | None = None,
+        limit: int = 50,
+    ) -> list[ImageGeneration]:
+        stmt = (
+            select(ImageGeneration)
+            .where(ImageGeneration.user_id == user_id)
+            .order_by(ImageGeneration.created_at.desc())
+        )
+        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 get_user_api_keys(self, user_id: str) -> list[dict]:
+        stmt = (
+            select(ApiKey)
+            .where(ApiKey.user_id == user_id)
+            .order_by(ApiKey.created_at.desc())
+        )
+        result = await self.db.execute(stmt)
+        keys = result.scalars().all()
+        # Return masked keys — only show key_prefix
+        return [
+            {
+                "id": k.id,
+                "name": k.name,
+                "key_prefix": k.key_prefix,
+                "is_active": k.is_active,
+                "last_used_at": k.last_used_at.isoformat() if k.last_used_at else None,
+                "created_at": k.created_at.isoformat(),
+                "expires_at": k.expires_at.isoformat() if k.expires_at else None,
+            }
+            for k in keys
+        ]

kairo/backend/services/agent_service.py

@@ -0,0 +1,107 @@
+import json
+import logging
+from datetime import datetime, UTC
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.models.agent import Agent
+from backend.schemas.agent import RegisterAgentRequest, UpdateAgentRequest
+
+logger = logging.getLogger(__name__)
+
+
+class AgentService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def register(self, user_id: str, req: RegisterAgentRequest) -> Agent:
+        agent = Agent(
+            user_id=user_id,
+            name=req.name,
+            description=req.description,
+            system_prompt=req.system_prompt,
+            model_preference=req.model_preference,
+            tools_config=json.dumps(req.tools) if req.tools else None,
+        )
+        self.db.add(agent)
+        await self.db.commit()
+        await self.db.refresh(agent)
+        logger.info("Agent registered: user=%s name=%s id=%s", user_id, req.name, agent.id)
+        return agent
+
+    async def list_agents(self, user_id: str) -> list[Agent]:
+        stmt = (
+            select(Agent)
+            .where(Agent.user_id == user_id)
+            .order_by(Agent.created_at.desc())
+        )
+        result = await self.db.execute(stmt)
+        return list(result.scalars().all())
+
+    async def get_agent(self, user_id: str, agent_id: str) -> Agent | None:
+        stmt = select(Agent).where(Agent.id == agent_id, Agent.user_id == user_id)
+        result = await self.db.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def update_agent(self, user_id: str, agent_id: str, req: UpdateAgentRequest) -> Agent | None:
+        agent = await self.get_agent(user_id, agent_id)
+        if not agent:
+            return None
+        if req.name is not None:
+            agent.name = req.name
+        if req.description is not None:
+            agent.description = req.description
+        if req.system_prompt is not None:
+            agent.system_prompt = req.system_prompt
+        if req.model_preference is not None:
+            agent.model_preference = req.model_preference
+        if req.tools is not None:
+            agent.tools_config = json.dumps(req.tools)
+        agent.updated_at = datetime.now(UTC)
+        await self.db.commit()
+        await self.db.refresh(agent)
+        return agent
+
+    async def delete_agent(self, user_id: str, agent_id: str) -> bool:
+        agent = await self.get_agent(user_id, agent_id)
+        if not agent:
+            return False
+        await self.db.delete(agent)
+        await self.db.commit()
+        logger.info("Agent deleted: id=%s user=%s", agent_id, user_id)
+        return True
+
+    async def heartbeat(self, agent_id: str, user_id: str, status: str) -> Agent | None:
+        """Update agent heartbeat. user_id comes from the API key owner."""
+        agent = await self.get_agent(user_id, agent_id)
+        if not agent:
+            return None
+        agent.status = status
+        agent.last_heartbeat_at = datetime.now(UTC)
+        agent.updated_at = datetime.now(UTC)
+        await self.db.commit()
+        await self.db.refresh(agent)
+        return agent
+
+    async def mark_stale_agents_offline(self, threshold_seconds: int) -> int:
+        """Mark agents as offline if no heartbeat within threshold. Returns count."""
+        cutoff = datetime.now(UTC)
+        from datetime import timedelta
+        cutoff = cutoff - timedelta(seconds=threshold_seconds)
+        stmt = (
+            select(Agent)
+            .where(Agent.status != "offline")
+            .where(
+                (Agent.last_heartbeat_at < cutoff) | (Agent.last_heartbeat_at.is_(None))
+            )
+        )
+        result = await self.db.execute(stmt)
+        agents = list(result.scalars().all())
+        for agent in agents:
+            agent.status = "offline"
+            agent.updated_at = datetime.now(UTC)
+        if agents:
+            await self.db.commit()
+            logger.info("Marked %d agents as offline", len(agents))
+        return len(agents)

kairo/backend/services/api_key_service.py

@@ -0,0 +1,66 @@
+import hashlib
+import logging
+import uuid
+from datetime import datetime, timedelta, UTC
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.models.api_key import ApiKey
+
+logger = logging.getLogger(__name__)
+
+
+def _generate_raw_key() -> str:
+    return f"sk-kairo-{uuid.uuid4().hex}"
+
+
+class ApiKeyService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def create_key(
+        self, user_id: str, name: str, expires_in_days: int | None = None
+    ) -> tuple[ApiKey, str]:
+        """Create an API key. Returns (record, raw_key). Raw key shown only once."""
+        raw_key = _generate_raw_key()
+        prefix = raw_key[:20]
+        key_hash = hashlib.sha256(raw_key.encode()).hexdigest()
+        expires_at = (
+            datetime.now(UTC) + timedelta(days=expires_in_days)
+            if expires_in_days
+            else None
+        )
+
+        api_key = ApiKey(
+            user_id=user_id,
+            name=name,
+            key_prefix=prefix,
+            key_hash=key_hash,
+            expires_at=expires_at,
+        )
+        self.db.add(api_key)
+        await self.db.commit()
+        await self.db.refresh(api_key)
+        logger.info("API key created: user=%s name=%s prefix=%s", user_id, name, prefix)
+        return api_key, raw_key
+
+    async def list_keys(self, user_id: str) -> list[ApiKey]:
+        stmt = (
+            select(ApiKey)
+            .where(ApiKey.user_id == user_id)
+            .order_by(ApiKey.created_at.desc())
+        )
+        result = await self.db.execute(stmt)
+        return list(result.scalars().all())
+
+    async def revoke_key(self, user_id: str, key_id: str) -> bool:
+        stmt = select(ApiKey).where(ApiKey.id == key_id, ApiKey.user_id == user_id)
+        result = await self.db.execute(stmt)
+        api_key = result.scalar_one_or_none()
+        if not api_key:
+            return False
+        api_key.is_active = False
+        await self.db.commit()
+        logger.info("API key revoked: key=%s user=%s", key_id, user_id)
+        return True

kairo/backend/services/api_usage_service.py

@@ -0,0 +1,126 @@
+import logging
+from datetime import datetime, timezone, timedelta
+
+from sqlalchemy import select, func
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.config import settings
+from backend.models.api_usage import ApiUsageRecord
+from backend.models.user import PlanType, User
+
+logger = logging.getLogger(__name__)
+
+API_PLAN_LIMITS: dict[str, dict[str, int]] = {
+    PlanType.FREE.value: {
+        "daily": settings.API_DAILY_TOKEN_LIMIT,
+        "monthly": settings.API_MONTHLY_TOKEN_LIMIT,
+    },
+    PlanType.PRO.value: {
+        "daily": settings.API_PRO_DAILY_TOKEN_LIMIT,
+        "monthly": settings.API_PRO_MONTHLY_TOKEN_LIMIT,
+    },
+}
+
+
+def _get_api_limits(plan: str) -> tuple[int, int]:
+    limits = API_PLAN_LIMITS.get(plan, API_PLAN_LIMITS[PlanType.FREE.value])
+    return limits["daily"], limits["monthly"]
+
+
+class ApiUsageService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def record(
+        self,
+        api_key_id: str,
+        user_id: str,
+        model: str,
+        prompt_tokens: int,
+        completion_tokens: int,
+        endpoint: str,
+        agent_id: str | None = None,
+    ) -> ApiUsageRecord:
+        record = ApiUsageRecord(
+            api_key_id=api_key_id,
+            user_id=user_id,
+            agent_id=agent_id,
+            model=model,
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            endpoint=endpoint,
+        )
+        self.db.add(record)
+        await self.db.commit()
+        await self.db.refresh(record)
+        logger.info(
+            "API usage recorded: key=%s user=%s prompt=%d completion=%d",
+            api_key_id, user_id, prompt_tokens, completion_tokens,
+        )
+        return record
+
+    async def get_daily_usage(self, user_id: str) -> int:
+        now = datetime.now(timezone.utc)
+        start_of_day = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        stmt = (
+            select(
+                func.coalesce(
+                    func.sum(ApiUsageRecord.prompt_tokens + ApiUsageRecord.completion_tokens), 0
+                )
+            )
+            .where(ApiUsageRecord.user_id == user_id)
+            .where(ApiUsageRecord.created_at >= start_of_day)
+        )
+        result = await self.db.execute(stmt)
+        return result.scalar() or 0
+
+    async def get_monthly_usage(self, user_id: str) -> int:
+        now = datetime.now(timezone.utc)
+        start_of_month = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+        stmt = (
+            select(
+                func.coalesce(
+                    func.sum(ApiUsageRecord.prompt_tokens + ApiUsageRecord.completion_tokens), 0
+                )
+            )
+            .where(ApiUsageRecord.user_id == user_id)
+            .where(ApiUsageRecord.created_at >= start_of_month)
+        )
+        result = await self.db.execute(stmt)
+        return result.scalar() or 0
+
+    async def check_limits(self, user_id: str) -> tuple[bool, str]:
+        user = await self.db.get(User, user_id)
+        if not user:
+            return False, "User not found"
+
+        daily_limit, monthly_limit = _get_api_limits(user.plan)
+
+        daily = await self.get_daily_usage(user_id)
+        if daily >= daily_limit:
+            return False, "API daily token limit reached."
+
+        monthly = await self.get_monthly_usage(user_id)
+        if monthly >= monthly_limit:
+            return False, "API monthly token limit reached."
+
+        return True, ""
+
+    async def get_key_usage_summary(self, api_key_id: str, days: int = 30) -> list[dict]:
+        start = datetime.now(timezone.utc) - timedelta(days=days)
+        stmt = (
+            select(
+                func.date(ApiUsageRecord.created_at).label("date"),
+                func.sum(ApiUsageRecord.prompt_tokens + ApiUsageRecord.completion_tokens).label("total_tokens"),
+                func.count().label("request_count"),
+            )
+            .where(ApiUsageRecord.api_key_id == api_key_id)
+            .where(ApiUsageRecord.created_at >= start)
+            .group_by(func.date(ApiUsageRecord.created_at))
+            .order_by(func.date(ApiUsageRecord.created_at))
+        )
+        result = await self.db.execute(stmt)
+        return [
+            {"date": str(r.date), "total_tokens": r.total_tokens or 0, "requests": r.request_count}
+            for r in result.all()
+        ]

kairo/backend/services/auth_service.py

@@ -0,0 +1,101 @@
+import logging
+import secrets
+from datetime import datetime, timedelta, timezone
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.core.security import hash_password, verify_password
+from backend.models.user import User
+
+logger = logging.getLogger(__name__)
+
+
+class AuthService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def register(self, email: str, password: str) -> User | None:
+        """Create a new user with a verification token. Returns None if email taken."""
+        existing = await self._get_by_email(email)
+        if existing:
+            return None
+        token = secrets.token_urlsafe(32)
+        user = User(
+            email=email,
+            hashed_password=hash_password(password),
+            email_verification_token=token,
+        )
+        self.db.add(user)
+        await self.db.commit()
+        await self.db.refresh(user)
+        logger.info("Registered user %s (id=%s)", email, user.id)
+        return user
+
+    async def authenticate(self, email: str, password: str) -> User | None:
+        """Verify credentials. Returns User or None."""
+        user = await self._get_by_email(email)
+        if not user or not verify_password(password, user.hashed_password):
+            return None
+        return user
+
+    async def get_user_by_id(self, user_id: str) -> User | None:
+        result = await self.db.execute(select(User).where(User.id == user_id))
+        return result.scalar_one_or_none()
+
+    async def verify_email(self, token: str) -> User | None:
+        """Mark email as verified if token is valid. Returns user or None."""
+        result = await self.db.execute(
+            select(User).where(User.email_verification_token == token)
+        )
+        user = result.scalar_one_or_none()
+        if not user:
+            return None
+        user.email_verified = True
+        user.email_verification_token = None
+        await self.db.commit()
+        await self.db.refresh(user)
+        logger.info("Email verified for user %s", user.email)
+        return user
+
+    async def request_password_reset(self, email: str) -> str | None:
+        """Generate a reset token with 1hr expiry. Returns token or None if no user."""
+        user = await self._get_by_email(email)
+        if not user:
+            return None
+        token = secrets.token_urlsafe(32)
+        user.password_reset_token = token
+        user.password_reset_expires = datetime.now(timezone.utc) + timedelta(hours=1)
+        await self.db.commit()
+        return token
+
+    async def reset_password(self, token: str, new_password: str) -> bool:
+        """Reset password using token. Returns True on success."""
+        result = await self.db.execute(
+            select(User).where(User.password_reset_token == token)
+        )
+        user = result.scalar_one_or_none()
+        if not user:
+            return False
+        if not user.password_reset_expires or user.password_reset_expires < datetime.now(timezone.utc):
+            return False
+        user.hashed_password = hash_password(new_password)
+        user.password_reset_token = None
+        user.password_reset_expires = None
+        await self.db.commit()
+        logger.info("Password reset for user %s", user.email)
+        return True
+
+    async def regenerate_verification_token(self, user_id: str) -> str | None:
+        """Generate a new verification token for resending. Returns token or None."""
+        user = await self.get_user_by_id(user_id)
+        if not user or user.email_verified:
+            return None
+        token = secrets.token_urlsafe(32)
+        user.email_verification_token = token
+        await self.db.commit()
+        return token
+
+    async def _get_by_email(self, email: str) -> User | None:
+        result = await self.db.execute(select(User).where(User.email == email))
+        return result.scalar_one_or_none()