kubsome 1.0.0__py3-none-any.whl

api/app.py

@@ -0,0 +1,48 @@
+"""
+Kubsome API — FastAPI backend exposing the Kubernetes engine.
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pathlib import Path
+
+from api.routes import pods, overview, contexts, events, metrics, logs, deployments, diagnostics, intelligence, terminal, operations, ws
+
+app = FastAPI(
+    title="Kubsome API",
+    version="1.0.0",
+    description="Kubernetes Operations Engine API",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://localhost:3001"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(pods.router, prefix="/api")
+app.include_router(overview.router, prefix="/api")
+app.include_router(contexts.router, prefix="/api")
+app.include_router(events.router, prefix="/api")
+app.include_router(metrics.router, prefix="/api")
+app.include_router(logs.router, prefix="/api")
+app.include_router(deployments.router, prefix="/api")
+app.include_router(diagnostics.router, prefix="/api")
+app.include_router(intelligence.router, prefix="/api")
+app.include_router(terminal.router, prefix="/api")
+app.include_router(operations.router, prefix="/api")
+app.include_router(ws.router)
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+# Serve Angular build in production
+ui_dist = Path(__file__).parent.parent / "ui" / "dist" / "ui" / "browser"
+if ui_dist.exists():
+    app.mount("/", StaticFiles(directory=str(ui_dist), html=True), name="ui")

api/routes/contexts.py

@@ -0,0 +1,77 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from core.kubeconfig import enriched_contexts
+from core.context_switcher import find_context, switch_context
+from core.context import context
+
+router = APIRouter(tags=["contexts"])
+
+
+class SwitchRequest(BaseModel):
+    name: str
+
+
+@router.get("/contexts")
+def get_contexts():
+    return {
+        "current": context.current_context,
+        "namespace": context.namespace,
+        "contexts": enriched_contexts(),
+    }
+
+
+@router.post("/switch-context")
+def post_switch_context(req: SwitchRequest):
+    matches = find_context(req.name)
+    if not matches:
+        raise HTTPException(status_code=404, detail="No matching context")
+
+    target = matches[0]
+    switch_context(target)
+    return {
+        "switched_to": target["name"],
+        "namespace": target["namespace"],
+        "environment": target.get("environment"),
+    }
+
+
+class NamespaceRequest(BaseModel):
+    namespace: str
+
+
+@router.get("/namespaces")
+def get_namespaces():
+    import subprocess
+    result = subprocess.run(
+        f"kubectl --context {context.current_context} get namespaces -o jsonpath='{{.items[*].metadata.name}}'",
+        shell=True, capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        return {"namespaces": [], "current": context.namespace}
+    raw = result.stdout.strip().strip("'")
+    namespaces = sorted([ns for ns in raw.split() if ns])
+    return {"namespaces": namespaces, "current": context.namespace}
+
+
+@router.post("/switch-namespace")
+def post_switch_namespace(req: NamespaceRequest):
+    from core.state import save_state
+    context.namespace = req.namespace
+    save_state(context.current_context, context.namespace)
+    return {"namespace": context.namespace}
+
+
+@router.get("/namespaces/{ctx}")
+def get_namespaces_for(ctx: str):
+    """Get namespaces for a specific context without switching global state."""
+    import subprocess
+    result = subprocess.run(
+        f"kubectl --context {ctx} get namespaces -o jsonpath='{{.items[*].metadata.name}}'",
+        shell=True, capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        return {"namespaces": []}
+    raw = result.stdout.strip().strip("'")
+    namespaces = sorted([ns for ns in raw.split() if ns])
+    return {"namespaces": namespaces}

api/routes/deployments.py

@@ -0,0 +1,62 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from core.context import context
+from core.collectors.deployments import collect_deployments
+from core.collectors.rollouts import (
+    rollout_status, rollout_history,
+    rollout_rollback, rollout_restart,
+)
+
+import subprocess
+
+router = APIRouter(tags=["deployments"])
+
+
+class ScaleRequest(BaseModel):
+    replicas: int
+
+
+@router.get("/deployments")
+def get_deployments():
+    return {
+        "context": context.current_context,
+        "namespace": context.namespace,
+        "deployments": collect_deployments(),
+    }
+
+
+@router.get("/rollout/{name}")
+def get_rollout(name: str):
+    status = rollout_status(name)
+    history = rollout_history(name)
+    return {"name": name, "status": status, "history": history}
+
+
+@router.post("/restart/{name}")
+def post_restart(name: str):
+    success, output = rollout_restart(name)
+    if not success:
+        raise HTTPException(status_code=500, detail="Restart failed")
+    return {"restarted": name}
+
+
+@router.post("/rollback/{name}")
+def post_rollback(name: str):
+    success, output = rollout_rollback(name)
+    if not success:
+        raise HTTPException(status_code=500, detail="Rollback failed")
+    return {"rolled_back": name}
+
+
+@router.post("/scale/{name}")
+def post_scale(name: str, req: ScaleRequest):
+    cmd = (
+        f"kubectl --context {context.current_context} "
+        f"scale deployment/{name} "
+        f"--replicas={req.replicas} -n {context.namespace}"
+    )
+    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise HTTPException(status_code=500, detail=result.stderr.strip())
+    return {"scaled": name, "replicas": req.replicas}

api/routes/diagnostics.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter, HTTPException
+
+from core.context import context
+from core.collectors.inspect import inspect_pod, pod_events, extract_pod_details
+from core.collectors.diagnosis import collect_diagnosis
+from core.collectors.trace import trace_resource
+from core.diagnostics.engine import diagnose
+from core.diagnostics.recommendations import recommend
+
+router = APIRouter(tags=["diagnostics"])
+
+
+@router.get("/inspect/{pod}")
+def get_inspect(pod: str):
+    pod_data = inspect_pod(pod)
+    if not pod_data:
+        raise HTTPException(status_code=404, detail="Pod not found")
+    details = extract_pod_details(pod_data)
+    events = pod_events(pod)
+    recommendation = recommend(pod_data)
+    return {
+        "pod": pod,
+        "details": details,
+        "events": events,
+        "recommendation": recommendation,
+    }
+
+
+@router.get("/diagnose/{pod}")
+def get_diagnose(pod: str):
+    data = collect_diagnosis(pod)
+    if not data:
+        raise HTTPException(status_code=404, detail="Pod not found")
+    findings = diagnose(data)
+    return {
+        "pod": pod,
+        "findings": findings,
+    }
+
+
+@router.get("/trace/{name}")
+def get_trace(name: str):
+    data = trace_resource(name)
+    return {"name": name, "trace": data}

api/routes/events.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter
+
+from core.collectors.events import collect_events
+from core.context import context
+
+router = APIRouter(tags=["events"])
+
+
+@router.get("/events")
+def get_events(limit: int = 50):
+    events = collect_events(limit=limit)
+    return {
+        "context": context.current_context,
+        "namespace": context.namespace,
+        "events": events,
+    }

api/routes/intelligence.py

@@ -0,0 +1,63 @@
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+
+from core.collectors.search import search_resources
+from core.collectors.security import security_scan
+from core.collectors.cost import resource_recommendations, find_unused_resources
+from core.healthcheck import run_health_check
+from core.ai.engine import handle_ai_query
+from core.ai.anomaly import detect_anomalies
+
+router = APIRouter(tags=["intelligence"])
+
+
+class AiRequest(BaseModel):
+    query: str
+
+
+@router.get("/search")
+def get_search(q: str = Query(..., min_length=1)):
+    results = search_resources(q)
+    return {"query": q, "results": results}
+
+
+@router.get("/security")
+def get_security():
+    findings = security_scan()
+    return {"findings": findings}
+
+
+@router.get("/health-check")
+def get_health_check():
+    return run_health_check()
+
+
+@router.get("/anomalies")
+def get_anomalies():
+    alerts = detect_anomalies()
+    return {"alerts": alerts}
+
+
+@router.get("/optimize")
+def get_optimize():
+    recs = resource_recommendations()
+    return {"recommendations": recs}
+
+
+@router.get("/unused")
+def get_unused():
+    return {"resources": find_unused_resources()}
+
+
+@router.post("/ai")
+def post_ai(req: AiRequest):
+    import re
+    response = handle_ai_query(req.query)
+    # Strip Rich markup tags for API consumers
+    content = response.get("content", "")
+    content = re.sub(r'\[/?[^\]]+\]', '', content)
+    return {
+        "title": response.get("title", "").replace("🤖 ", ""),
+        "answer": content,
+        "severity": response.get("severity", "info"),
+    }

api/routes/logs.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter, Query
+from fastapi.responses import StreamingResponse
+
+from core.context import context
+from core.collectors.logs import fetch_logs, stream_logs
+
+router = APIRouter(tags=["logs"])
+
+
+@router.get("/logs/{pod}")
+def get_logs(
+    pod: str,
+    tail: int = Query(100, ge=1, le=5000),
+    errors: bool = False,
+    previous: bool = False,
+):
+    lines = fetch_logs(pod, tail=tail, previous=previous, errors_only=errors)
+    return {
+        "pod": pod,
+        "namespace": context.namespace,
+        "lines": lines,
+        "count": len(lines),
+    }
+
+
+@router.get("/logs/{pod}/stream")
+def get_logs_stream(pod: str):
+    def generate():
+        process = stream_logs(pod)
+        try:
+            for line in process.stdout:
+                yield line
+        finally:
+            process.kill()
+
+    return StreamingResponse(generate(), media_type="text/plain")

api/routes/metrics.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+
+from core.collectors.metrics import top_pods, top_nodes
+from core.context import context
+
+router = APIRouter(tags=["metrics"])
+
+
+@router.get("/top/pods")
+def get_top_pods():
+    return {
+        "context": context.current_context,
+        "namespace": context.namespace,
+        "pods": top_pods(),
+    }
+
+
+@router.get("/top/nodes")
+def get_top_nodes():
+    return {
+        "context": context.current_context,
+        "nodes": top_nodes(),
+    }

api/routes/operations.py

@@ -0,0 +1,279 @@
+import re
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+from typing import Optional
+
+from core.context import context
+
+router = APIRouter(tags=["operations"])
+
+
+# ─── Image Pull Secrets ───────────────────────────────────────────────────────
+
+@router.get("/image-pull-secrets")
+def get_image_pull_secrets(pod: Optional[str] = None):
+    from core.collectors.image_pull import check_image_pull_secrets
+    return check_image_pull_secrets(pod)
+
+
+# ─── Incident Mode ───────────────────────────────────────────────────────────
+
+class IncidentStartRequest(BaseModel):
+    title: str = ""
+
+class NoteRequest(BaseModel):
+    text: str
+
+@router.post("/incident/start")
+def incident_start(req: IncidentStartRequest):
+    from core.incident.manager import start_incident
+    incident = start_incident(req.title)
+    return incident
+
+@router.post("/incident/stop")
+def incident_stop():
+    from core.incident.manager import stop_incident
+    result = stop_incident()
+    if not result:
+        return {"status": "no active incident"}
+    incident, path = result
+    return {"incident": incident, "export_path": path}
+
+@router.get("/incident/status")
+def incident_status():
+    from core.incident.manager import get_active
+    return get_active() or {"status": "no active incident"}
+
+@router.post("/incident/note")
+def incident_note(req: NoteRequest):
+    from core.incident.manager import add_note
+    if add_note(req.text):
+        return {"added": True}
+    return {"added": False, "reason": "no active incident"}
+
+@router.post("/incident/snapshot")
+def incident_snapshot():
+    from core.incident.manager import snapshot
+    if snapshot():
+        return {"captured": True}
+    return {"captured": False, "reason": "no active incident"}
+
+
+# ─── RBAC ─────────────────────────────────────────────────────────────────────
+
+@router.get("/rbac")
+def get_rbac():
+    from core.collectors.rbac import list_role_bindings
+    return {"bindings": list_role_bindings()}
+
+
+# ─── CronJobs / Jobs ─────────────────────────────────────────────────────────
+
+@router.get("/cronjobs")
+def get_cronjobs():
+    from core.collectors.jobs import list_cronjobs
+    return {"cronjobs": list_cronjobs()}
+
+@router.get("/jobs")
+def get_jobs():
+    from core.collectors.jobs import list_jobs
+    return {"jobs": list_jobs()}
+
+@router.post("/trigger/{name}")
+def trigger_cronjob(name: str):
+    from core.collectors.jobs import trigger_cronjob as do_trigger
+    success, output = do_trigger(name)
+    return {"success": success, "output": output}
+
+
+# ─── Namespace Overview ───────────────────────────────────────────────────────
+
+@router.get("/ns-overview")
+def get_ns_overview():
+    from core.collectors.namespace import namespace_summary
+    return namespace_summary()
+
+
+# ─── Compare (Multi-cluster) ─────────────────────────────────────────────────
+
+class CompareRequest(BaseModel):
+    ctx_a: str
+    ctx_b: str
+    ns_a: str = "default"
+    ns_b: str = "default"
+
+@router.post("/compare")
+def post_compare(req: CompareRequest):
+    from core.collectors.multicluster import compare_contexts
+    data = compare_contexts(req.ctx_a, req.ctx_b, req.ns_a, req.ns_b)
+    return data
+
+
+# ─── Network ─────────────────────────────────────────────────────────────────
+
+@router.get("/netcheck/{pod}")
+def get_netcheck(pod: str):
+    from core.collectors.network import netcheck
+    return netcheck(pod)
+
+
+# ─── ConfigMap / Secret ───────────────────────────────────────────────────────
+
+@router.get("/configmap/{name}")
+def get_configmap(name: str):
+    from core.collectors.configs import get_configmap as fetch_cm
+    return fetch_cm(name)
+
+@router.get("/secret/{name}")
+def get_secret(name: str):
+    from core.collectors.configs import get_secret as fetch_secret
+    return fetch_secret(name)
+
+
+# ─── Deployment Diff ──────────────────────────────────────────────────────────
+
+@router.get("/diff/{name}")
+def get_diff(name: str):
+    from core.collectors.diff import deployment_diff
+    return deployment_diff(name)
+
+
+# ─── Scaling: HPA, PDB, Capacity, Quota, Drain ───────────────────────────────
+
+@router.get("/hpa")
+def get_hpa():
+    from core.collectors.scaling import list_hpa
+    return {"hpa": list_hpa()}
+
+@router.get("/pdb")
+def get_pdb():
+    from core.collectors.scaling import list_pdb
+    return {"pdb": list_pdb()}
+
+@router.get("/capacity")
+def get_capacity():
+    from core.collectors.scaling import cluster_capacity
+    return cluster_capacity()
+
+@router.get("/quota")
+def get_quota():
+    from core.collectors.scaling import namespace_quota
+    return namespace_quota()
+
+@router.get("/drain-check/{node}")
+def get_drain_check(node: str):
+    from core.collectors.scaling import drain_check
+    return drain_check(node)
+
+
+# ─── Timeline ────────────────────────────────────────────────────────────────
+
+@router.get("/timeline")
+def get_timeline(minutes: int = 60):
+    from core.collectors.timeline import build_timeline
+    return {"events": build_timeline(minutes=minutes)}
+
+
+# ─── Ingress / Mesh / Dependencies / DNS ──────────────────────────────────────
+
+@router.get("/ingress")
+def get_ingress():
+    from core.collectors.services import list_ingresses
+    return {"ingresses": list_ingresses()}
+
+@router.get("/mesh")
+def get_mesh():
+    from core.collectors.services import detect_mesh
+    return detect_mesh()
+
+@router.get("/deps/{name}")
+def get_deps(name: str):
+    from core.collectors.services import service_dependencies
+    return service_dependencies(name)
+
+@router.get("/dns/{service}")
+def get_dns(service: str):
+    from core.collectors.services import dns_debug
+    return dns_debug(service)
+
+
+# ─── Correlate / Playbook ─────────────────────────────────────────────────────
+
+@router.get("/correlate")
+def get_correlate(target: Optional[str] = None):
+    from core.ai.correlation import correlate
+    return {"chains": correlate(target)}
+
+@router.get("/playbook/{issue}")
+def get_playbook(issue: str):
+    from core.ai.playbooks import get_playbook
+    return get_playbook(issue)
+
+
+# ─── Changelog / Snap ─────────────────────────────────────────────────────────
+
+@router.get("/changelog")
+def get_changelog():
+    from core.collectors.changes import build_changelog
+    return {"changelog": build_changelog()}
+
+@router.post("/snap")
+def post_snap():
+    from core.collectors.changes import take_state_snapshot
+    path = take_state_snapshot()
+    return {"path": path}
+
+@router.get("/snap-diff")
+def get_snap_diff():
+    from core.collectors.changes import get_latest_snapshot, diff_snapshots
+    old = get_latest_snapshot()
+    return diff_snapshots(old)
+
+
+# ─── Labels ───────────────────────────────────────────────────────────────────
+
+@router.get("/labels/{resource_type}")
+def get_labels(resource_type: str, name: Optional[str] = None):
+    from core.collectors.labels import get_labels as fetch_labels
+    return {"resources": fetch_labels(resource_type, name)}
+
+
+# ─── Audit ────────────────────────────────────────────────────────────────────
+
+@router.get("/audit")
+def get_audit():
+    from core.audit import get_audit_log
+    return {"log": get_audit_log()}
+
+
+# ─── Export ───────────────────────────────────────────────────────────────────
+
+@router.get("/export")
+def get_export(format: str = "md"):
+    from core.export import export_report
+    path = export_report(format=format)
+    return {"path": path, "format": format}
+
+
+# ─── Explain / Generate ───────────────────────────────────────────────────────
+
+class ExplainRequest(BaseModel):
+    query: str
+
+class GenerateRequest(BaseModel):
+    kind: str
+    name: str
+
+@router.post("/explain")
+def post_explain(req: ExplainRequest):
+    from core.ai.explain import explain
+    result = explain(req.query)
+    # Strip Rich markup
+    content = re.sub(r'\[/?[^\]]+\]', '', result.get("content", ""))
+    return {"title": result.get("title", ""), "content": content}
+
+@router.post("/generate")
+def post_generate(req: GenerateRequest):
+    from core.ai.generator import generate_manifest
+    yaml_output = generate_manifest(req.kind, req.name, context.namespace)
+    return {"yaml": yaml_output or ""}