kairo-code 0.1.0__tar.gz → 0.2.0__tar.gz

{kairo_code-0.1.0 → kairo_code-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kairo-code
-Version: 0.1.0
+Version: 0.2.0
 Summary: Kairo Code - AI Coding Assistant by Kairon Labs
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

kairo_code-0.2.0/kairo/backend/api/agents.py

@@ -0,0 +1,415 @@
+from datetime import datetime, UTC
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.config import settings
+from backend.core.api_key_auth import get_api_key_user
+from backend.core.database import get_db
+from backend.core.dependencies import get_current_user
+from backend.models.api_key import ApiKey
+from backend.models.user import User
+from backend.schemas.agent import (
+    AgentHeartbeatRequest,
+    AgentHeartbeatResponse,
+    AgentResponse,
+    AgentListResponse,
+    RegisterAgentRequest,
+    UpdateAgentRequest,
+    AgentMetricsResponse,
+    AgentEventResponse,
+    IssueCommandRequest,
+    CommandResponse,
+    CreateAlertConfigRequest,
+    UpdateAlertConfigRequest,
+    AlertConfigResponse,
+    AlertHistoryResponse,
+    SetupTokenResponse,
+    AgentRegistrationRequest,
+    AgentRegistrationResponse,
+    TelemetryBatchRequest,
+    TelemetryBatchResponse,
+    AgentCommand,
+)
+from backend.services.agent_service import AgentService
+
+router = APIRouter(prefix="/agents", tags=["Agents"])
+
+
+def _check_enabled():
+    if not settings.FEATURE_KAIRO_AGENTS_ENABLED:
+        raise HTTPException(status_code=503, detail="Kairo Agents is coming soon.")
+
+
+# ─── CRUD ─────────────────────────────────────────────────────────────────────
+
+@router.post("/", response_model=AgentResponse)
+async def register_agent(
+    req: RegisterAgentRequest,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Create a new agent."""
+    _check_enabled()
+    svc = AgentService(db)
+    agent = await svc.register(user.id, req)
+    return agent
+
+
+@router.get("/", response_model=list[AgentListResponse])
+async def list_agents(
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """List all agents with 24h summary metrics."""
+    _check_enabled()
+    svc = AgentService(db)
+    agents = await svc.list_agents_with_metrics(user.id)
+    return agents
+
+
+@router.get("/{agent_id}", response_model=AgentResponse)
+async def get_agent(
+    agent_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Get agent details."""
+    _check_enabled()
+    svc = AgentService(db)
+    agent = await svc.get_agent(user.id, agent_id)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return agent
+
+
+@router.patch("/{agent_id}", response_model=AgentResponse)
+async def update_agent(
+    agent_id: str,
+    req: UpdateAgentRequest,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Update agent configuration."""
+    _check_enabled()
+    svc = AgentService(db)
+    agent = await svc.update_agent(user.id, agent_id, req)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return agent
+
+
+@router.delete("/{agent_id}")
+async def delete_agent(
+    agent_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Delete an agent (soft delete)."""
+    _check_enabled()
+    svc = AgentService(db)
+    deleted = await svc.delete_agent(user.id, agent_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return {"deleted": True}
+
+
+# ─── Setup & Registration ─────────────────────────────────────────────────────
+
+@router.post("/{agent_id}/setup-token", response_model=SetupTokenResponse)
+async def generate_setup_token(
+    agent_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Generate a one-time setup token for agent registration."""
+    _check_enabled()
+    svc = AgentService(db)
+    result = await svc.generate_setup_token(user.id, agent_id)
+    if not result:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    token, expires_at = result
+    return SetupTokenResponse(token=token, expires_at=expires_at, agent_id=agent_id)
+
+
+@router.post("/register", response_model=AgentRegistrationResponse)
+async def register_with_token(
+    req: AgentRegistrationRequest,
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+):
+    """Register an agent using a setup token. Returns agent config and API key."""
+    _check_enabled()
+    client_ip = request.client.host if request.client else None
+    svc = AgentService(db)
+
+    # Consume token
+    agent = await svc.consume_setup_token(req.setup_token, client_ip)
+    if not agent:
+        raise HTTPException(status_code=401, detail="Invalid or expired setup token")
+
+    # Update SDK version
+    agent.sdk_version = req.sdk_version
+    if req.host_info:
+        agent.host_info = req.host_info.model_dump()
+    await db.commit()
+
+    # Create agent-scoped API key
+    api_key, _ = await svc.create_agent_api_key(agent.user_id, agent.id, agent.name)
+
+    return AgentRegistrationResponse(
+        agent_id=agent.id,
+        name=agent.name,
+        model_preference=agent.model_preference,
+        system_prompt=agent.system_prompt,
+        api_key=api_key,
+    )
+
+
+@router.get("/{agent_id}/connection-status")
+async def get_connection_status(
+    agent_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Poll for agent connection status (for wizard verification step)."""
+    _check_enabled()
+    svc = AgentService(db)
+    agent = await svc.get_agent(user.id, agent_id)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return {
+        "connected": agent.first_connected_at is not None,
+        "state": agent.state,
+        "first_connected_at": agent.first_connected_at,
+        "sdk_version": agent.sdk_version,
+        "host_info": agent.host_info,
+    }
+
+
+# ─── Heartbeat ────────────────────────────────────────────────────────────────
+
+@router.post("/heartbeat", response_model=AgentHeartbeatResponse)
+async def agent_heartbeat(
+    req: AgentHeartbeatRequest,
+    request: Request,
+    auth: tuple[User, ApiKey] = Depends(get_api_key_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Agent heartbeat — authenticated via API key. Returns pending commands."""
+    _check_enabled()
+    user, _api_key = auth
+    client_ip = request.client.host if request.client else None
+
+    svc = AgentService(db)
+    agent, commands = await svc.heartbeat(req.agent_id, user.id, req, client_ip)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found or not owned by this key's user")
+
+    return AgentHeartbeatResponse(
+        acknowledged=True,
+        server_time=datetime.now(UTC),
+        commands=[
+            AgentCommand(
+                command_id=cmd["command_id"],
+                type=cmd["type"],
+                payload=cmd["payload"],
+                issued_at=cmd["issued_at"],
+                expires_at=cmd["expires_at"],
+                signature=cmd["signature"],
+            )
+            for cmd in commands
+        ],
+    )
+
+
+# ─── Commands ─────────────────────────────────────────────────────────────────
+
+@router.post("/{agent_id}/restart", response_model=CommandResponse)
+async def restart_agent(
+    agent_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Request agent restart."""
+    _check_enabled()
+    svc = AgentService(db)
+    req = IssueCommandRequest(command_type="restart")
+    command = await svc.issue_command(user.id, agent_id, req)
+    if not command:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return command
+
+
+@router.post("/{agent_id}/stop", response_model=CommandResponse)
+async def stop_agent(
+    agent_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Request agent stop."""
+    _check_enabled()
+    svc = AgentService(db)
+    req = IssueCommandRequest(command_type="stop")
+    command = await svc.issue_command(user.id, agent_id, req)
+    if not command:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return command
+
+
+@router.post("/{agent_id}/command", response_model=CommandResponse)
+async def issue_command(
+    agent_id: str,
+    req: IssueCommandRequest,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Issue a command to an agent."""
+    _check_enabled()
+    svc = AgentService(db)
+    command = await svc.issue_command(user.id, agent_id, req)
+    if not command:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return command
+
+
+# ─── Metrics ──────────────────────────────────────────────────────────────────
+
+@router.get("/{agent_id}/metrics", response_model=AgentMetricsResponse)
+async def get_agent_metrics(
+    agent_id: str,
+    range: str = Query("24h", pattern="^(1h|6h|24h|7d|30d)$"),
+    granularity: str = Query("auto", pattern="^(auto|1m|1h|1d)$"),
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Get agent metrics for a time range."""
+    _check_enabled()
+    svc = AgentService(db)
+    metrics = await svc.get_metrics(user.id, agent_id, range, granularity)
+    if metrics is None:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return metrics
+
+
+# ─── Events ───────────────────────────────────────────────────────────────────
+
+@router.get("/{agent_id}/events", response_model=list[AgentEventResponse])
+async def get_agent_events(
+    agent_id: str,
+    event_type: str | None = Query(None),
+    limit: int = Query(50, ge=1, le=500),
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Get agent events."""
+    _check_enabled()
+    svc = AgentService(db)
+    events = await svc.get_events(user.id, agent_id, event_type, limit)
+    if events is None:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return events
+
+
+# ─── Alerts ───────────────────────────────────────────────────────────────────
+
+@router.get("/{agent_id}/alerts", response_model=list[AlertConfigResponse])
+async def get_alert_configs(
+    agent_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Get alert configurations for an agent."""
+    _check_enabled()
+    svc = AgentService(db)
+    configs = await svc.get_alert_configs(user.id, agent_id)
+    if configs is None:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return configs
+
+
+@router.post("/{agent_id}/alerts", response_model=AlertConfigResponse)
+async def create_alert_config(
+    agent_id: str,
+    req: CreateAlertConfigRequest,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Create an alert configuration."""
+    _check_enabled()
+    svc = AgentService(db)
+    config = await svc.create_alert_config(user.id, agent_id, req)
+    if not config:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return config
+
+
+@router.patch("/{agent_id}/alerts/{config_id}", response_model=AlertConfigResponse)
+async def update_alert_config(
+    agent_id: str,
+    config_id: str,
+    req: UpdateAlertConfigRequest,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Update an alert configuration."""
+    _check_enabled()
+    svc = AgentService(db)
+    config = await svc.update_alert_config(user.id, agent_id, config_id, req)
+    if not config:
+        raise HTTPException(status_code=404, detail="Alert config not found")
+    return config
+
+
+@router.delete("/{agent_id}/alerts/{config_id}")
+async def delete_alert_config(
+    agent_id: str,
+    config_id: str,
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Delete an alert configuration."""
+    _check_enabled()
+    svc = AgentService(db)
+    deleted = await svc.delete_alert_config(user.id, agent_id, config_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Alert config not found")
+    return {"deleted": True}
+
+
+@router.get("/{agent_id}/alerts/history", response_model=list[AlertHistoryResponse])
+async def get_alert_history(
+    agent_id: str,
+    limit: int = Query(50, ge=1, le=500),
+    user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Get alert history for an agent."""
+    _check_enabled()
+    svc = AgentService(db)
+    history = await svc.get_alert_history(user.id, agent_id, limit)
+    if history is None:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return history
+
+
+# ─── SDK Telemetry ────────────────────────────────────────────────────────────
+
+@router.post("/telemetry/batch", response_model=TelemetryBatchResponse)
+async def submit_telemetry_batch(
+    req: TelemetryBatchRequest,
+    auth: tuple[User, ApiKey] = Depends(get_api_key_user),
+    db: AsyncSession = Depends(get_db),
+):
+    """Submit a batch of telemetry events from the SDK."""
+    _check_enabled()
+    user, api_key = auth
+
+    # Verify agent belongs to user
+    svc = AgentService(db)
+    agent = await svc.get_agent(user.id, req.agent_id)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+
+    accepted, rejected, errors = await svc.process_telemetry_batch(req.agent_id, req)
+    return TelemetryBatchResponse(accepted=accepted, rejected=rejected, errors=errors)

{kairo_code-0.1.0 → kairo_code-0.2.0}/kairo/backend/app.py

@@ -8,8 +8,10 @@ from pathlib import Path
 import httpx
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
+from starlette.responses import Response
 from starlette.types import ASGIApp, Receive, Scope, Send
 
 from backend.core.database import init_db
@@ -124,6 +126,60 @@ async def lifespan(app: FastAPI):
     agent_task = asyncio.create_task(_agent_staleness_loop())
     logger.info("Agent staleness checker started (60s interval)")
 
+    # Background task for hourly metrics rollup
+    async def _metrics_rollup_hourly_loop():
+        from backend.core.database import async_session
+        from backend.services.agent_service import AgentService
+        # Wait 5 minutes after startup before first run
+        await asyncio.sleep(300)
+        while True:
+            try:
+                async with async_session() as db:
+                    svc = AgentService(db)
+                    await svc.rollup_1m_to_1h()
+            except Exception as e:
+                logger.warning("Hourly metrics rollup error: %s", e)
+            await asyncio.sleep(3600)  # Every hour
+
+    metrics_hourly_task = asyncio.create_task(_metrics_rollup_hourly_loop())
+    logger.info("Hourly metrics rollup started (3600s interval)")
+
+    # Background task for daily metrics rollup
+    async def _metrics_rollup_daily_loop():
+        from backend.core.database import async_session
+        from backend.services.agent_service import AgentService
+        # Wait 10 minutes after startup before first run
+        await asyncio.sleep(600)
+        while True:
+            try:
+                async with async_session() as db:
+                    svc = AgentService(db)
+                    await svc.rollup_1h_to_daily()
+                    await svc.cleanup_old_metrics()
+                    await svc.cleanup_old_events()
+            except Exception as e:
+                logger.warning("Daily metrics rollup error: %s", e)
+            await asyncio.sleep(86400)  # Every 24 hours
+
+    metrics_daily_task = asyncio.create_task(_metrics_rollup_daily_loop())
+    logger.info("Daily metrics rollup started (86400s interval)")
+
+    # Background task for alert evaluation
+    async def _alert_evaluation_loop():
+        from backend.core.database import async_session
+        from backend.services.agent_service import AgentService
+        while True:
+            try:
+                async with async_session() as db:
+                    svc = AgentService(db)
+                    await svc.evaluate_alerts()
+            except Exception as e:
+                logger.warning("Alert evaluation error: %s", e)
+            await asyncio.sleep(60)  # Every minute
+
+    alert_task = asyncio.create_task(_alert_evaluation_loop())
+    logger.info("Alert evaluation started (60s interval)")
+
     # Background task to clean up expired device codes
     async def _device_code_cleanup_loop():
         from backend.core.database import async_session
@@ -222,6 +278,9 @@ async def lifespan(app: FastAPI):
     agent_task.cancel()
     device_cleanup_task.cancel()
     uptime_task.cancel()
+    metrics_hourly_task.cancel()
+    metrics_daily_task.cancel()
+    alert_task.cancel()
     await app.state.llm_service.close()
     logger.info("Kairo shutting down")
 
@@ -231,6 +290,9 @@ def create_app() -> FastAPI:
 
     app = FastAPI(title="Kairo", version="0.1.0", lifespan=lifespan)
 
+    # GZip compression for responses > 500 bytes
+    app.add_middleware(GZipMiddleware, minimum_size=500)
+
     # CORS — configurable via env
     origins = [o.strip() for o in settings.CORS_ORIGINS.split(",") if o.strip()]
     app.add_middleware(
@@ -270,20 +332,38 @@ def create_app() -> FastAPI:
     app.include_router(device_auth_router, prefix="/api")
     app.include_router(files_router, prefix="/api")
 
-    # Serve static frontend build
+    # Serve static frontend build with proper cache headers
     static_dir = Path(__file__).parent / "static"
     if static_dir.exists():
-        app.mount("/assets", StaticFiles(directory=static_dir / "assets"), name="assets")
+        # Custom middleware to add cache headers for assets
+        class CachedStaticFiles(StaticFiles):
+            async def __call__(self, scope, receive, send):
+                async def send_with_cache(message):
+                    if message["type"] == "http.response.start":
+                        headers = list(message.get("headers", []))
+                        # Hashed assets are immutable - cache for 1 year
+                        headers.append((b"cache-control", b"public, max-age=31536000, immutable"))
+                        message["headers"] = headers
+                    await send(message)
+                await super().__call__(scope, receive, send_with_cache)
+
+        app.mount("/assets", CachedStaticFiles(directory=static_dir / "assets"), name="assets")
 
         @app.get("/{full_path:path}")
         async def serve_spa(full_path: str):
             file_path = (static_dir / full_path).resolve()
             # Path traversal guard
             if not str(file_path).startswith(str(static_dir.resolve())):
-                return FileResponse(static_dir / "index.html")
+                return FileResponse(
+                    static_dir / "index.html",
+                    headers={"Cache-Control": "no-cache, must-revalidate"}
+                )
             if file_path.is_file():
                 return FileResponse(file_path)
-            return FileResponse(static_dir / "index.html")
+            return FileResponse(
+                static_dir / "index.html",
+                headers={"Cache-Control": "no-cache, must-revalidate"}
+            )
 
     return app
 

{kairo_code-0.1.0 → kairo_code-0.2.0}/kairo/backend/config.py

@@ -118,13 +118,15 @@ class Settings(BaseSettings):
 
     # Context window limits per model (in estimated tokens).
     # Reserve space for system prompt + response.
+    # Small models (nyx-lite) get tighter limits to leave room for output
+    # and trigger earlier compression for better quality.
     CONTEXT_LIMITS: dict[str, int] = {
         "nyx": 6000,       # 8k context, reserve 2k for response
-        "nyx-lite": 4000,  # 8k context, conservative reserve for 14B
+        "nyx-lite": 3000,  # 8k context, aggressive reserve for 14B quality
         "theron": 14000,   # 16k+ context
         "helios": 14000,   # 16k+ context
     }
-    SUMMARY_TRIGGER_TOKENS: int = 4000  # Summarize history when it exceeds this
+    SUMMARY_TRIGGER_TOKENS: int = 3000  # Summarize history when it exceeds this (lower for quality)
 
     MODEL_MAP: dict[str, str] = {
         "nyx": "nyx",