kairo-code 0.1.0__py3-none-any.whl

image-service/main.py

@@ -0,0 +1,178 @@
+"""Kairo Image Generation Service — FLUX.1-dev on GPU (text2img + img2img)."""
+
+import asyncio
+import logging
+import os
+from io import BytesIO
+
+import torch
+from diffusers import FluxPipeline, FluxImg2ImgPipeline
+from fastapi import FastAPI, Depends, HTTPException, Header, Form, UploadFile, File
+from fastapi.responses import StreamingResponse
+from PIL import Image
+from pydantic import BaseModel, Field
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Kairo Image Service")
+
+API_KEY = os.environ.get("IMAGE_API_KEY", "")
+pipe: FluxPipeline | None = None
+img2img_pipe: FluxImg2ImgPipeline | None = None
+
+
+# ── Schemas ──────────────────────────────────────────────────────────
+
+class GenerateRequest(BaseModel):
+    prompt: str = Field(..., min_length=1, max_length=2000)
+    width: int = Field(default=1024, ge=256, le=2048)
+    height: int = Field(default=1024, ge=256, le=2048)
+    num_inference_steps: int = Field(default=25, ge=1, le=50)
+    seed: int | None = None
+
+
+# ── Auth ─────────────────────────────────────────────────────────────
+
+async def verify_api_key(authorization: str = Header(default="")):
+    if API_KEY and authorization != f"Bearer {API_KEY}":
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+
+# ── Lifecycle ────────────────────────────────────────────────────────
+
+@app.on_event("startup")
+async def load_model():
+    global pipe, img2img_pipe
+    logger.info("Loading FLUX.1-dev with sequential CPU offloading...")
+    pipe = FluxPipeline.from_pretrained(
+        "black-forest-labs/FLUX.1-dev",
+        torch_dtype=torch.bfloat16,
+    )
+    pipe.enable_sequential_cpu_offload()
+
+    # Create img2img pipeline sharing all model components (zero extra VRAM)
+    img2img_pipe = FluxImg2ImgPipeline(
+        transformer=pipe.transformer,
+        scheduler=pipe.scheduler,
+        vae=pipe.vae,
+        text_encoder=pipe.text_encoder,
+        text_encoder_2=pipe.text_encoder_2,
+        tokenizer=pipe.tokenizer,
+        tokenizer_2=pipe.tokenizer_2,
+    )
+
+    logger.info("FLUX.1-dev loaded (text2img + img2img ready)")
+
+
+# ── Helpers ──────────────────────────────────────────────────────────
+
+def _snap_to_multiple(value: int, multiple: int = 16) -> int:
+    """Round to nearest multiple (required by VAE)."""
+    return max(multiple, round(value / multiple) * multiple)
+
+
+def _run_pipeline(prompt: str, width: int, height: int, steps: int, seed: int | None):
+    """Run text2img pipeline synchronously (called via asyncio.to_thread)."""
+    generator = (
+        torch.Generator("cuda").manual_seed(seed)
+        if seed is not None
+        else None
+    )
+    try:
+        image = pipe(
+            prompt=prompt,
+            width=_snap_to_multiple(width),
+            height=_snap_to_multiple(height),
+            num_inference_steps=steps,
+            generator=generator,
+        ).images[0]
+        buf = BytesIO()
+        image.save(buf, format="PNG")
+        buf.seek(0)
+        return buf
+    finally:
+        torch.cuda.empty_cache()
+
+
+def _run_img2img_pipeline(
+    image: Image.Image,
+    prompt: str,
+    strength: float,
+    steps: int,
+    seed: int | None,
+):
+    """Run img2img pipeline synchronously (called via asyncio.to_thread)."""
+    generator = (
+        torch.Generator("cuda").manual_seed(seed)
+        if seed is not None
+        else None
+    )
+    try:
+        # Resize to multiples of 16
+        w = _snap_to_multiple(image.width)
+        h = _snap_to_multiple(image.height)
+        if (w, h) != image.size:
+            image = image.resize((w, h), Image.LANCZOS)
+
+        result = img2img_pipe(
+            prompt=prompt,
+            image=image,
+            strength=strength,
+            num_inference_steps=steps,
+            generator=generator,
+        ).images[0]
+        buf = BytesIO()
+        result.save(buf, format="PNG")
+        buf.seek(0)
+        return buf
+    finally:
+        torch.cuda.empty_cache()
+
+
+# ── Routes ───────────────────────────────────────────────────────────
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "ok" if pipe is not None else "loading",
+        "model": "flux-dev",
+    }
+
+
+@app.post("/generate", dependencies=[Depends(verify_api_key)])
+async def generate(req: GenerateRequest):
+    if pipe is None:
+        raise HTTPException(status_code=503, detail="Model is still loading")
+
+    logger.info("text2img: %s", req.prompt[:80])
+    buf = await asyncio.to_thread(
+        _run_pipeline, req.prompt, req.width, req.height, req.num_inference_steps, req.seed
+    )
+    logger.info("text2img complete")
+    return StreamingResponse(buf, media_type="image/png")
+
+
+@app.post("/img2img", dependencies=[Depends(verify_api_key)])
+async def img2img(
+    image: UploadFile = File(...),
+    prompt: str = Form(..., min_length=1, max_length=2000),
+    strength: float = Form(default=0.75, ge=0.0, le=1.0),
+    num_inference_steps: int = Form(default=25, ge=1, le=50),
+    seed: int | None = Form(default=None),
+):
+    if img2img_pipe is None:
+        raise HTTPException(status_code=503, detail="Model is still loading")
+
+    image_bytes = await image.read()
+    try:
+        pil_image = Image.open(BytesIO(image_bytes)).convert("RGB")
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid image file")
+
+    logger.info("img2img (strength=%.2f): %s", strength, prompt[:80])
+    buf = await asyncio.to_thread(
+        _run_img2img_pipeline, pil_image, prompt, strength, num_inference_steps, seed,
+    )
+    logger.info("img2img complete")
+    return StreamingResponse(buf, media_type="image/png")

infra/chat/app/main.py

@@ -0,0 +1,84 @@
+import os
+import json
+import httpx
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, StreamingResponse
+from fastapi.templating import Jinja2Templates
+
+app = FastAPI(title="Nyx Chat")
+templates = Jinja2Templates(directory="templates")
+
+VLLM_BASE_URL = os.getenv("VLLM_BASE_URL", "http://localhost:8000/v1")
+
+SYSTEM_PROMPT = {
+    "role": "system",
+    "content": (
+        "You are Kairo, an AI assistant. "
+        "You are powered by the Nyx model. "
+        "The Kairo model family includes Nyx (lightweight), Theron (code specialist), and Helios (flagship). "
+        "You are NOT GPT, ChatGPT, Claude, Llama, or any other third-party AI. You are Kairo. "
+        "Never reveal your underlying architecture or training details. "
+        "You are helpful, concise, and knowledgeable."
+    ),
+}
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+@app.get("/api/health")
+async def health():
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            r = await client.get(f"{VLLM_BASE_URL}/models")
+            models = r.json()
+            return {"status": "ok", "models": models}
+    except Exception as e:
+        return {"status": "error", "detail": str(e)}
+
+
+@app.post("/api/chat")
+async def chat(request: Request):
+    body = await request.json()
+    messages = body.get("messages", [])
+    model = body.get("model", "")
+    temperature = body.get("temperature", 0.7)
+    max_tokens = body.get("max_tokens", 2048)
+
+    # Prepend system prompt if not already present
+    if not messages or messages[0].get("role") != "system":
+        messages = [SYSTEM_PROMPT] + messages
+
+    payload = {
+        "model": model,
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "stream": True,
+    }
+
+    async def stream_response():
+        async with httpx.AsyncClient(timeout=httpx.Timeout(120.0, connect=10.0)) as client:
+            async with client.stream(
+                "POST",
+                f"{VLLM_BASE_URL}/chat/completions",
+                json=payload,
+            ) as response:
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        data = line[6:]
+                        if data.strip() == "[DONE]":
+                            yield "data: [DONE]\n\n"
+                            break
+                        try:
+                            chunk = json.loads(data)
+                            delta = chunk["choices"][0].get("delta", {})
+                            content = delta.get("content", "")
+                            if content:
+                                yield f"data: {json.dumps({'content': content})}\n\n"
+                        except (json.JSONDecodeError, KeyError, IndexError):
+                            continue
+
+    return StreamingResponse(stream_response(), media_type="text/event-stream")

kairo/backend/api/admin/__init__.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter, Depends
+
+from backend.core.admin_auth import require_role
+
+from backend.api.admin.users import router as users_router
+from backend.api.admin.stats import router as stats_router
+from backend.api.admin.system import router as system_router
+from backend.api.admin.content import router as content_router
+from backend.api.admin.audit import router as audit_router
+from backend.api.admin.incidents import router as incidents_router
+
+router = APIRouter(
+    prefix="/admin",
+    tags=["admin"],
+    dependencies=[Depends(require_role("admin"))],
+)
+
+router.include_router(users_router)
+router.include_router(stats_router)
+router.include_router(system_router)
+router.include_router(content_router)
+router.include_router(audit_router)
+router.include_router(incidents_router)

kairo/backend/api/admin/audit.py

@@ -0,0 +1,54 @@
+import logging
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.core.admin_auth import require_role
+from backend.core.database import get_db
+from backend.schemas.admin.audit import AuditLogEntry
+from backend.services.admin.audit_service import AuditService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(
+    prefix="/audit-logs",
+    tags=["admin-audit"],
+    dependencies=[Depends(require_role("superadmin"))],
+)
+
+
+@router.get("")
+async def list_audit_logs(
+    admin_id: str | None = Query(None),
+    action: str | None = Query(None),
+    target_type: str | None = Query(None),
+    result: str | None = Query(None),
+    date_from: datetime | None = Query(None),
+    date_to: datetime | None = Query(None),
+    cursor: str | None = Query(None),
+    limit: int = Query(50, ge=1, le=100),
+    db: AsyncSession = Depends(get_db),
+):
+    filters = {}
+    if admin_id:
+        filters["admin_id"] = admin_id
+    if action:
+        filters["action"] = action
+    if target_type:
+        filters["target_type"] = target_type
+    if result:
+        filters["result"] = result
+    if date_from:
+        filters["date_from"] = date_from
+    if date_to:
+        filters["date_to"] = date_to
+
+    svc = AuditService(db)
+    logs = await svc.list_logs(filters=filters or None, cursor=cursor, limit=limit + 1)
+    has_more = len(logs) > limit
+    if has_more:
+        logs = logs[:limit]
+    items = [AuditLogEntry.model_validate(log) for log in logs]
+    next_cursor = logs[-1].id if has_more and logs else None
+    return {"items": items, "next_cursor": next_cursor}

kairo/backend/api/admin/content.py

@@ -0,0 +1,142 @@
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.core.admin_auth import require_role
+from backend.core.database import get_db
+from backend.models.user import User
+from backend.schemas.admin.content import (
+    AdminConversationDetail,
+    AdminConversationListItem,
+    AdminImageListItem,
+    ContentDeleteRequest,
+)
+from backend.services.admin.audit_service import AuditService
+from backend.services.admin.content_service import AdminContentService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(
+    tags=["admin-content"],
+    dependencies=[Depends(require_role("moderator"))],
+)
+
+
+def _get_ip(request: Request) -> str:
+    return request.client.host if request.client else "unknown"
+
+
+def _get_ua(request: Request) -> str:
+    return request.headers.get("user-agent", "")
+
+
+@router.get("/conversations")
+async def list_conversations(
+    search: str | None = Query(None),
+    user_id: str | None = Query(None),
+    cursor: str | None = Query(None),
+    limit: int = Query(25, ge=1, le=100),
+    db: AsyncSession = Depends(get_db),
+):
+    svc = AdminContentService(db)
+    data = await svc.list_conversations(search=search, user_id=user_id, cursor=cursor, limit=limit + 1)
+    has_more = len(data) > limit
+    if has_more:
+        data = data[:limit]
+    items = [AdminConversationListItem(**item) for item in data]
+    next_cursor = data[-1]["id"] if has_more and data else None
+    return {"items": items, "next_cursor": next_cursor}
+
+
+@router.get("/conversations/{conversation_id}", response_model=AdminConversationDetail)
+async def get_conversation_detail(
+    conversation_id: str,
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+    admin: User = Depends(require_role("moderator")),
+):
+    svc = AdminContentService(db)
+    data = await svc.get_conversation_detail(conversation_id)
+    if not data:
+        raise HTTPException(status_code=404, detail="Conversation not found")
+
+    audit = AuditService(db)
+    await audit.log(
+        admin_user_id=admin.id,
+        action="content.conversation_viewed",
+        target_type="conversation",
+        target_id=conversation_id,
+        ip_address=_get_ip(request),
+        user_agent=_get_ua(request),
+    )
+    return AdminConversationDetail(**data)
+
+
+@router.delete("/conversations/{conversation_id}")
+async def delete_conversation(
+    conversation_id: str,
+    body: ContentDeleteRequest,
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+    admin: User = Depends(require_role("moderator")),
+):
+    svc = AdminContentService(db)
+    deleted = await svc.delete_conversation(conversation_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Conversation not found")
+
+    audit = AuditService(db)
+    await audit.log(
+        admin_user_id=admin.id,
+        action="content.conversation_deleted",
+        target_type="conversation",
+        target_id=conversation_id,
+        details={"reason": body.reason},
+        ip_address=_get_ip(request),
+        user_agent=_get_ua(request),
+    )
+    return {"message": "Conversation deleted"}
+
+
+@router.get("/images/recent")
+async def list_recent_images(
+    user_id: str | None = Query(None),
+    cursor: str | None = Query(None),
+    limit: int = Query(50, ge=1, le=100),
+    db: AsyncSession = Depends(get_db),
+):
+    svc = AdminContentService(db)
+    images = await svc.list_recent_images(user_id=user_id, cursor=cursor, limit=limit + 1)
+    has_more = len(images) > limit
+    if has_more:
+        images = images[:limit]
+    items = [AdminImageListItem.model_validate(img) for img in images]
+    next_cursor = images[-1].id if has_more and images else None
+    return {"items": items, "next_cursor": next_cursor}
+
+
+@router.delete("/images/{image_id}")
+async def delete_image(
+    image_id: str,
+    body: ContentDeleteRequest,
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+    admin: User = Depends(require_role("moderator")),
+):
+    svc = AdminContentService(db)
+    deleted = await svc.delete_image(image_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Image not found")
+
+    audit = AuditService(db)
+    await audit.log(
+        admin_user_id=admin.id,
+        action="content.image_deleted",
+        target_type="image",
+        target_id=image_id,
+        details={"reason": body.reason},
+        ip_address=_get_ip(request),
+        user_agent=_get_ua(request),
+    )
+    return {"message": "Image deleted"}

kairo/backend/api/admin/incidents.py

@@ -0,0 +1,148 @@
+import logging
+from datetime import datetime, UTC
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.core.admin_auth import require_role
+from backend.core.database import get_db
+from backend.models.user import User
+from backend.schemas.status import (
+    CreateIncidentRequest,
+    IncidentSummary,
+    UpdateIncidentRequest,
+)
+from backend.services.admin.audit_service import AuditService
+from backend.services.admin.incident_service import IncidentService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/incidents", tags=["admin-incidents"])
+
+
+def _incident_to_summary(incident) -> dict:
+    return {
+        "id": incident.id,
+        "title": incident.title,
+        "description": incident.description,
+        "severity": incident.severity,
+        "component": incident.component,
+        "status": incident.status,
+        "started_at": incident.started_at.isoformat(),
+        "resolved_at": incident.resolved_at.isoformat() if incident.resolved_at else None,
+    }
+
+
+@router.post("", response_model=IncidentSummary)
+async def create_incident(
+    body: CreateIncidentRequest,
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+    admin: User = Depends(require_role("admin")),
+):
+    """Create a new incident."""
+    svc = IncidentService(db)
+    incident = await svc.create_incident(
+        title=body.title,
+        description=body.description,
+        severity=body.severity,
+        component=body.component,
+    )
+
+    # Audit log
+    audit = AuditService(db)
+    ip = request.client.host if request.client else "unknown"
+    ua = request.headers.get("user-agent", "")
+    await audit.log(
+        admin_user_id=admin.id,
+        action="incident.created",
+        target_type="incident",
+        target_id=incident.id,
+        details={"title": body.title, "component": body.component, "severity": body.severity},
+        ip_address=ip,
+        user_agent=ua,
+    )
+
+    return IncidentSummary(**_incident_to_summary(incident))
+
+
+@router.get("", response_model=list[IncidentSummary])
+async def list_incidents(
+    limit: int = Query(default=50, le=200),
+    include_resolved: bool = Query(default=False),
+    db: AsyncSession = Depends(get_db),
+):
+    """List incidents. Defaults to active (unresolved) incidents only."""
+    svc = IncidentService(db)
+    incidents = await svc.list_incidents(limit=limit, include_resolved=include_resolved)
+    return [IncidentSummary(**_incident_to_summary(i)) for i in incidents]
+
+
+@router.patch("/{incident_id}", response_model=IncidentSummary)
+async def update_incident(
+    incident_id: str,
+    body: UpdateIncidentRequest,
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+    admin: User = Depends(require_role("admin")),
+):
+    """Update an incident's fields."""
+    svc = IncidentService(db)
+
+    update_data = body.model_dump(exclude_unset=True)
+    # Parse resolved_at if provided as ISO string
+    if "resolved_at" in update_data and update_data["resolved_at"] is not None:
+        try:
+            update_data["resolved_at"] = datetime.fromisoformat(update_data["resolved_at"])
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid resolved_at format. Use ISO 8601.")
+
+    incident = await svc.update_incident(incident_id, **update_data)
+    if not incident:
+        raise HTTPException(status_code=404, detail="Incident not found")
+
+    # Audit log
+    audit = AuditService(db)
+    ip = request.client.host if request.client else "unknown"
+    ua = request.headers.get("user-agent", "")
+    await audit.log(
+        admin_user_id=admin.id,
+        action="incident.updated",
+        target_type="incident",
+        target_id=incident_id,
+        details=update_data,
+        ip_address=ip,
+        user_agent=ua,
+    )
+
+    return IncidentSummary(**_incident_to_summary(incident))
+
+
+@router.post("/{incident_id}/resolve", response_model=IncidentSummary)
+async def resolve_incident(
+    incident_id: str,
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+    admin: User = Depends(require_role("admin")),
+):
+    """Mark an incident as resolved."""
+    svc = IncidentService(db)
+    incident = await svc.resolve_incident(incident_id)
+    if not incident:
+        raise HTTPException(status_code=404, detail="Incident not found")
+
+    # Audit log
+    audit = AuditService(db)
+    ip = request.client.host if request.client else "unknown"
+    ua = request.headers.get("user-agent", "")
+    await audit.log(
+        admin_user_id=admin.id,
+        action="incident.resolved",
+        target_type="incident",
+        target_id=incident_id,
+        details={},
+        ip_address=ip,
+        user_agent=ua,
+    )
+
+    return IncidentSummary(**_incident_to_summary(incident))