Sync from GitHub on master (Wed Nov 19 12:57:50 UTC 2025)

app.py

@@ -1,156 +1,42 @@
 #!/usr/bin/env python3
 
 import os
-import re
 import time
-import uuid
-import yaml
-from typing import Tuple
-
+import re
+import requests
 import gradio as gr
 
-from agentctl.config import settings
-from agentctl.k8s_client import K8sClient
-from agentctl.agent import K8sAgent
-
-
-# ---------------------------------------------------------------------
-# Core - Agent + Client
-# ---------------------------------------------------------------------
-
-agent = K8sAgent()
-
-def _get_client() -> K8sClient:
-    return K8sClient()
-
-
-# ---------------------------------------------------------------------
-# Unique Name Injection
-# ---------------------------------------------------------------------
-
-def _inject_unique_name(yaml_text: str) -> str:
-    """
-    Add unique suffix to metadata.name for Job, Deployment, CronJob.
-    Prevents 409 AlreadyExists errors.
-    """
-    try:
-        data = yaml.safe_load(yaml_text)
-        if not isinstance(data, dict):
-            return yaml_text
-
-        kind = data.get("kind")
-        if kind not in {"Job", "CronJob", "Deployment"}:
-            return yaml_text
-
-        base = data["metadata"]["name"]
-        suffix = str(uuid.uuid4())[:5]
-        new_name = f"{base}-{suffix}"
-        data["metadata"]["name"] = new_name
-
-        # Patch CronJob template labels
-        if kind == "CronJob":
-            jt = data["spec"]["jobTemplate"]["spec"]["template"]
-            if "metadata" in jt:
-                if "labels" in jt["metadata"]:
-                    jt["metadata"]["labels"]["app"] = new_name
-                else:
-                    jt["metadata"]["labels"] = {"app": new_name}
-
-        return yaml.safe_dump(data)
-
-    except Exception:
-        return yaml_text
-
-
-# ---------------------------------------------------------------------
-# YAML Generation + Apply
-# ---------------------------------------------------------------------
-
-def generate_yaml_from_prompt(prompt: str, namespace: str, kind: str) -> str:
-    if not prompt.strip():
-        return "# Enter a description, e.g. 'run a python preprocessing job'"
-
-    ns = namespace.strip() or settings.k8s_namespace
-    kind_sel = None if kind == "Auto" else kind
-
-    _, yaml_text = agent.nl_to_resource_yaml(prompt, namespace=ns, kind=kind_sel)
-    return yaml_text
-
-
-def apply_yaml_to_cluster(yaml_text: str) -> Tuple[str, str]:
-    if not yaml_text.strip():
-        return "No YAML to apply.", ""
-
-    yaml_text = _inject_unique_name(yaml_text)
-
-    client = _get_client()
-    result = client.apply_manifest(yaml_text)
-
-    try:
-        raw = str(result.raw_response)
-    except:
-        raw = "<unserialisable>"
-
-    prefix = "✅" if result.success else "❌"
-    return f"{prefix} {result.message}", raw
-
 
 # ---------------------------------------------------------------------
-# Cluster Snapshot
+# Backend URL (FastAPI)
 # ---------------------------------------------------------------------
+BACKEND_URL = os.getenv("BACKEND_URL", "http://127.0.0.1:9000")
 
-def get_cluster_snapshot() -> str:
-    client = _get_client()
-    snap = client.snapshot()
 
-    out = [f"Namespace: {snap.namespace}", ""]
+def _post(path: str, payload: dict):
+    """POST helper"""
+    url = f"{BACKEND_URL}{path}"
+    resp = requests.post(url, json=payload)
+    resp.raise_for_status()
+    return resp.json()
 
-    out.append("Jobs:")
-    if not snap.jobs:
-        out.append("  (no jobs)")
-    else:
-        for j in snap.jobs:
-            out.append(
-                f"  - {j.name}: succeeded={j.succeeded}, failed={j.failed}, active={j.active}"
-            )
 
-    out.append("")
-    out.append("Pods:")
-    if not snap.pods:
-        out.append("  (no pods)")
-    else:
-        for p in snap.pods:
-            out.append(f"  - {p.name}: phase={p.phase}")
-
-    out.append("")
-    out.append("Deployments:")
-    if not snap.deployments:
-        out.append("  (no deployments)")
-    else:
-        for d in snap.deployments:
-            out.append(f"  - {d.name}: replicas={d.replicas}, ready={d.ready}")
-
-    out.append("")
-    out.append("CronJobs:")
-    if not snap.cronjobs:
-        out.append("  (no cronjobs)")
-    else:
-        for c in snap.cronjobs:
-            last = c.last_schedule or "never"
-            out.append(f"  - {c.name}: active={c.active}, lastScheduleTime={last}")
-
-    return "\n".join(out)
+def _get(path: str):
+    """GET helper"""
+    url = f"{BACKEND_URL}{path}"
+    resp = requests.get(url)
+    resp.raise_for_status()
+    return resp.json()
 
 
 # ---------------------------------------------------------------------
-# Logs System
+# Colorize Logs (same as before)
 # ---------------------------------------------------------------------
-
 def _colorize_logs(text: str) -> str:
     if not text:
         return "<span style='color:#888;'>No logs</span>"
 
-    html_lines = []
+    html = []
     for line in text.splitlines():
         if re.search(r"(error|failed|exception)", line, re.IGNORECASE):
             color = "#ff4b4b"
@@ -162,38 +48,61 @@ def _colorize_logs(text: str) -> str:
             color = "#d0d0d0"
 
         safe = line.replace("<", "&lt;").replace(">", "&gt;")
-        html_lines.append(f"<span style='color:{color};'>{safe}</span>")
+        html.append(f"<span style='color:{color};'>{safe}</span>")
 
-    return "<br>".join(html_lines)
+    return "<br>".join(html)
 
 
-def get_pod_logs_once(pod_name: str, tail_lines: int) -> str:
-    pod_name = pod_name.strip()
-    if not pod_name:
-        return "<span style='color:#ff4b4b;'>Enter a pod name.</span>"
+# ---------------------------------------------------------------------
+# UI Connected Functions (call backend)
+# ---------------------------------------------------------------------
+
+def generate_yaml(prompt: str, namespace: str, kind: str) -> str:
+    payload = {
+        "prompt": prompt,
+        "namespace": namespace,
+        "kind": kind
+    }
+    result = _post("/api/generate-yaml", payload)
+    return result["yaml"]
 
-    client = _get_client()
-    raw = client.get_pod_logs(pod_name, tail_lines)
-    return _colorize_logs(raw)
 
+def apply_yaml(yaml_text: str):
+    payload = {"yaml": yaml_text}
+    result = _post("/api/apply", payload)
+    return result["status"], result["raw"]
 
-def follow_pod_logs(pod_name: str, tail_lines: int):
-    pod_name = pod_name.strip()
-    if not pod_name:
-        yield "<span style='color:#ff4b4b;'>Enter a pod name.</span>"
+
+def get_snapshot() -> str:
+    result = _get("/api/snapshot")
+    return result["snapshot"]
+
+
+def get_logs_once(pod_name: str, tail: int) -> str:
+    if not pod_name.strip():
+        return "<span style='color:#ff4b4b;'>Enter a pod name</span>"
+
+    result = _get(f"/api/logs?pod={pod_name}&tail={tail}")
+    logs = result.get("logs", "")
+    return _colorize_logs(logs)
+
+
+def follow_logs(pod_name: str, tail: int):
+    """Stream logs from backend."""
+    if not pod_name.strip():
+        yield "<span style='color:#ff4b4b;'>Enter a pod name</span>"
         return
 
-    client = _get_client()
     while True:
-        raw = client.get_pod_logs(pod_name, tail_lines)
-        yield _colorize_logs(raw)
+        result = _get(f"/api/logs?pod={pod_name}&tail={tail}")
+        logs = result.get("logs", "")
+        yield _colorize_logs(logs)
         time.sleep(2)
 
 
 # ---------------------------------------------------------------------
-# Logs CSS
+# CSS (same as before)
 # ---------------------------------------------------------------------
-
 TERMINAL_CSS = """
 #logs_terminal {
     background-color: #111;
@@ -210,41 +119,43 @@ TERMINAL_CSS = """
 
 
 # ---------------------------------------------------------------------
-# UI
+# UI (identical to original UI)
 # ---------------------------------------------------------------------
 
 def build_app() -> gr.Blocks:
     with gr.Blocks(
         title="AgentCTL: LLM-Driven Kubernetes Automation",
-        css=TERMINAL_CSS,
+        css=TERMINAL_CSS
     ) as demo:
 
-        gr.Markdown("""
+        gr.Markdown(f"""
 ### 🔧 Environment
-- `K8S_API_BASE_URL`  
+
+Connected to backend: **{BACKEND_URL}**
+
+- `K8S_API_BASE_URL` (backend)
 - `K8S_NAMESPACE`  
-- `K8S_VERIFY_SSL`  
-- `OPENAI_API_KEY` (optional)
+- K8s proxy + FastAPI → ngrok → HuggingFace  
 ---
 """)
 
-        # Create Resource
+        # CREATE RESOURCE TAB
         with gr.Tab("Create Resource"):
             with gr.Row():
                 prompt = gr.Textbox(
-                    label="Describe the resource",
+                    label="Describe resource",
+                    lines=5,
                     placeholder=(
                         "- run a python job\n"
-                        "- create an nginx deployment with 3 replicas\n"
-                        "- schedule a cleanup script every 5 minutes\n"
+                        "- 3-replica nginx deployment\n"
+                        "- cronjob every 5 minutes"
                     ),
-                    lines=5,
                 )
 
                 with gr.Column():
                     namespace = gr.Textbox(
                         label="Namespace",
-                        value=settings.k8s_namespace,
+                        value="default"
                     )
                     kind = gr.Dropdown(
                         label="Resource kind",
@@ -252,56 +163,56 @@ def build_app() -> gr.Blocks:
                         value="Auto",
                     )
 
-            generate_btn = gr.Button("Generate YAML", variant="primary")
+            gen_btn = gr.Button("Generate YAML", variant="primary")
             yaml_box = gr.Code(language="yaml", lines=22, label="Generated YAML")
 
             apply_btn = gr.Button("Apply to cluster")
             apply_msg = gr.Textbox(label="Status")
-            apply_debug = gr.Textbox(label="Raw API Response")
+            apply_raw = gr.Textbox(label="API Raw Response")
 
-            generate_btn.click(
-                generate_yaml_from_prompt,
+            gen_btn.click(
+                generate_yaml,
                 inputs=[prompt, namespace, kind],
-                outputs=yaml_box,
+                outputs=yaml_box
             )
+
             apply_btn.click(
-                apply_yaml_to_cluster,
+                apply_yaml,
                 inputs=[yaml_box],
-                outputs=[apply_msg, apply_debug],
+                outputs=[apply_msg, apply_raw]
             )
 
-        # Dashboard
+        # DASHBOARD
         with gr.Tab("Cluster Dashboard"):
-            snapshot_btn = gr.Button("Refresh snapshot", variant="primary")
-            snapshot_box = gr.Textbox(lines=25, label="Cluster Overview")
+            snap_btn = gr.Button("Refresh snapshot", variant="primary")
+            snap_box = gr.Textbox(lines=25, label="Cluster Overview")
 
-            snapshot_btn.click(
-                get_cluster_snapshot,
+            snap_btn.click(
+                get_snapshot,
                 inputs=[],
-                outputs=snapshot_box,
+                outputs=snap_box
             )
 
-        # Logs
+        # LOGS TAB
         with gr.Tab("Pod Logs"):
-            pod_name = gr.Textbox(label="Pod name")
-            tail_lines = gr.Slider(10, 500, step=10, value=100, label="Tail lines")
+            pod_name = gr.Textbox(label="Pod Name")
+            tail = gr.Slider(10, 500, value=100, step=10, label="Tail lines")
 
-            get_logs_btn = gr.Button("Get logs once")
-            follow_logs_btn = gr.Button("Follow logs (live)", variant="primary")
+            logs_btn = gr.Button("Get logs once")
+            follow_btn = gr.Button("Follow logs (live)", variant="primary")
 
             logs_box = gr.HTML(elem_id="logs_terminal", label="Logs")
 
-            get_logs_btn.click(
-                get_pod_logs_once,
-                inputs=[pod_name, tail_lines],
-                outputs=logs_box,
+            logs_btn.click(
+                get_logs_once,
+                inputs=[pod_name, tail],
+                outputs=logs_box
             )
 
-            # FIXED: removed `stream=True`
-            follow_logs_btn.click(
-                follow_pod_logs,
-                inputs=[pod_name, tail_lines],
-                outputs=logs_box,
+            follow_btn.click(
+                follow_logs,
+                inputs=[pod_name, tail],
+                outputs=logs_box
             )
 
     return demo

backend/main.py

@@ -9,22 +9,24 @@ app = FastAPI(
     description="Backend API for Kubernetes AgentCTL automation",
 )
 
-# CORS (UI → API)
+# CORS (for Gradio UI, HF Space, other tools)
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # tighten later if needed
+    allow_origins=["*"],  # tighten later for prod
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Routers
-app.include_router(yaml_gen.router)
-app.include_router(apply.router)
-app.include_router(snapshot.router)
-app.include_router(logs.router)
 
-
-@app.get("/")
+@app.get("/", tags=["Status"])
 def root():
+    """Simple health endpoint."""
     return {"status": "AgentCTL Backend Running"}
+
+
+# Attach routers under /api/*
+app.include_router(yaml_gen.router, prefix="/api")
+app.include_router(apply.router, prefix="/api")
+app.include_router(snapshot.router, prefix="/api")
+app.include_router(logs.router, prefix="/api")

backend/routers/apply.py

@@ -1,37 +1,88 @@
+# backend/routers/apply.py
+
 from fastapi import APIRouter
 from pydantic import BaseModel
-import uuid, yaml
+import uuid
+import yaml
 
 from agentctl.k8s_client import K8sClient
 
-router = APIRouter(prefix="/api", tags=["Apply"])
+router = APIRouter(tags=["Apply Manifest"])
 
-client = K8sClient()
 
 class ApplyRequest(BaseModel):
     yaml: str
 
+
 class ApplyResponse(BaseModel):
     success: bool
     message: str
-    raw: str
+    raw: str | None = None
+
 
-def inject_unique(yaml_text: str) -> str:
+def _inject_unique_name(yaml_text: str) -> str:
+    """
+    Add a short UUID suffix to metadata.name for Job/CronJob/Deployment
+    to avoid 409 AlreadyExists errors when users re-apply the same YAML.
+    """
     try:
-        obj = yaml.safe_load(yaml_text)
-        kind = obj.get("kind")
+        data = yaml.safe_load(yaml_text)
+        if not isinstance(data, dict):
+            return yaml_text
+
+        kind = data.get("kind")
+        if kind not in {"Job", "CronJob", "Deployment"}:
+            return yaml_text
+
+        meta = data.get("metadata") or {}
+        base_name = meta.get("name")
+        if not base_name:
+            return yaml_text
+
+        suffix = str(uuid.uuid4())[:5]
+        new_name = f"{base_name}-{suffix}"
+        meta["name"] = new_name
+        data["metadata"] = meta
 
-        if kind in ["Job", "CronJob", "Deployment"]:
-            suffix = str(uuid.uuid4())[:5]
-            obj["metadata"]["name"] += f"-{suffix}"
+        # For CronJob make sure template labels are consistent
+        if kind == "CronJob":
+            tmpl = (
+                data.get("spec", {})
+                .get("jobTemplate", {})
+                .get("spec", {})
+                .get("template", {})
+            )
+            if isinstance(tmpl, dict):
+                md = tmpl.get("metadata") or {}
+                labels = md.get("labels") or {}
+                labels["app"] = new_name
+                md["labels"] = labels
+                tmpl["metadata"] = md
 
-        return yaml.safe_dump(obj)
-    except:
+        return yaml.safe_dump(data)
+    except Exception:
+        # on failure, just return original yaml
         return yaml_text
 
+
 @router.post("/apply", response_model=ApplyResponse)
-def apply_resource(req: ApplyRequest):
-    final_yaml = inject_unique(req.yaml)
+def apply_manifest(req: ApplyRequest):
+    """
+    Apply a YAML manifest to the Kubernetes cluster via K8sClient.
+    """
+    # Lazy K8sClient instantiation so missing env vars don't crash import
+    client = K8sClient()
+
+    final_yaml = _inject_unique_name(req.yaml)
     result = client.apply_manifest(final_yaml)
-    raw = str(result.raw_response)
-    return ApplyResponse(success=result.success, message=result.message, raw=raw)
+
+    try:
+        raw_str = str(result.raw_response)
+    except Exception:
+        raw_str = None
+
+    return ApplyResponse(
+        success=result.success,
+        message=result.message,
+        raw=raw_str,
+    )

backend/routers/logs.py

@@ -1,11 +1,20 @@
-from fastapi import APIRouter
+# backend/routers/logs.py
+
+from fastapi import APIRouter, Query
+
 from agentctl.k8s_client import K8sClient
 
-router = APIRouter(prefix="/api", tags=["Logs"])
+router = APIRouter(tags=["Logs"])
 
-client = K8sClient()
 
 @router.get("/logs")
-def get_logs(pod_name: str, tail: int = 100):
-    logs = client.get_pod_logs(pod_name, tail)
-    return {"pod": pod_name, "tail": tail, "logs": logs}
+def get_logs(
+    pod_name: str = Query(..., description="Pod name from snapshot"),
+    tail: int = Query(100, ge=1, le=1000, description="Tail lines"),
+):
+    """
+    Return raw logs for a given pod (no HTML, just plain text).
+    """
+    client = K8sClient()
+    text = client.get_pod_logs(pod_name.strip(), tail_lines=tail)
+    return {"pod_name": pod_name, "tail": tail, "logs": text}

backend/routers/snapshot.py

@@ -1,19 +1,54 @@
+# backend/routers/snapshot.py
+
 from fastapi import APIRouter
+
 from agentctl.k8s_client import K8sClient
 
-router = APIRouter(prefix="/api", tags=["Snapshot"])
+router = APIRouter(tags=["Cluster Snapshot"])
 
-client = K8sClient()
 
 @router.get("/snapshot")
-def snapshot():
+def get_snapshot():
+    """
+    Return a JSON snapshot of Jobs, Pods, Deployments, CronJobs in the namespace.
+    """
+    client = K8sClient()
     snap = client.snapshot()
 
-    data = {
-        "namespace": snap.namespace,
-        "jobs": [vars(j) for j in snap.jobs],
-        "pods": [vars(p) for p in snap.pods],
-        "deployments": [vars(d) for d in snap.deployments],
-        "cronjobs": [vars(c) for c in snap.cronjobs],
+    def job_to_dict(j):
+        return {
+            "name": getattr(j, "name", None),
+            "succeeded": getattr(j, "succeeded", None),
+            "failed": getattr(j, "failed", None),
+            "active": getattr(j, "active", None),
+        }
+
+    def pod_to_dict(p):
+        return {
+            "name": getattr(p, "name", None),
+            "phase": getattr(p, "phase", None),
+        }
+
+    def deploy_to_dict(d):
+        return {
+            "name": getattr(d, "name", None),
+            "replicas": getattr(d, "replicas", None),
+            "ready": getattr(d, "ready", None),
+        }
+
+    def cron_to_dict(c):
+        return {
+            "name": getattr(c, "name", None),
+            "active": getattr(c, "active", None),
+            # your schema likely calls this last_schedule or lastScheduleTime
+            "last_schedule": getattr(c, "last_schedule", None)
+            or getattr(c, "lastScheduleTime", None),
+        }
+
+    return {
+        "namespace": getattr(snap, "namespace", None),
+        "jobs": [job_to_dict(j) for j in snap.jobs],
+        "pods": [pod_to_dict(p) for p in snap.pods],
+        "deployments": [deploy_to_dict(d) for d in snap.deployments],
+        "cronjobs": [cron_to_dict(c) for c in snap.cronjobs],
     }
-    return data

backend/routers/yaml_gen.py

@@ -1,23 +1,39 @@
+# backend/routers/yaml_gen.py
+
 from fastapi import APIRouter
 from pydantic import BaseModel
+
 from agentctl.agent import K8sAgent
 from agentctl.config import settings
 
-router = APIRouter(prefix="/api", tags=["YAML Generation"])
+router = APIRouter(tags=["YAML Generation"])
 
 agent = K8sAgent()
 
-class GenerateRequest(BaseModel):
+
+class GenerateYAMLRequest(BaseModel):
     prompt: str
     namespace: str | None = None
     kind: str | None = "Auto"
 
-class GenerateResponse(BaseModel):
+
+class GenerateYAMLResponse(BaseModel):
     yaml: str
 
-@router.post("/generate-yaml", response_model=GenerateResponse)
-def generate_yaml(req: GenerateRequest):
+
+@router.post("/generate-yaml", response_model=GenerateYAMLResponse)
+def generate_yaml(req: GenerateYAMLRequest):
+    """
+    Natural language → Kubernetes YAML using your K8sAgent.
+    """
     ns = req.namespace or settings.k8s_namespace
-    kind = None if req.kind == "Auto" else req.kind
-    _, yaml_text = agent.nl_to_resource_yaml(req.prompt, ns, kind)
-    return GenerateResponse(yaml=yaml_text)
+    kind_sel = None if (req.kind is None or req.kind == "Auto") else req.kind
+
+    # your existing agent logic returns (explanation, yaml_text)
+    _, yaml_text = agent.nl_to_resource_yaml(
+        req.prompt,
+        namespace=ns,
+        kind=kind_sel,
+    )
+
+    return GenerateYAMLResponse(yaml=yaml_text)

hf-space/backend/main.py

@@ -0,0 +1,30 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from backend.routers import yaml_gen, apply, snapshot, logs
+
+app = FastAPI(
+    title="AgentCTL Backend API",
+    version="1.0.0",
+    description="Backend API for Kubernetes AgentCTL automation",
+)
+
+# CORS (UI → API)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # tighten later if needed
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Routers
+app.include_router(yaml_gen.router)
+app.include_router(apply.router)
+app.include_router(snapshot.router)
+app.include_router(logs.router)
+
+
+@app.get("/")
+def root():
+    return {"status": "AgentCTL Backend Running"}

hf-space/backend/routers/apply.py

@@ -0,0 +1,37 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+import uuid, yaml
+
+from agentctl.k8s_client import K8sClient
+
+router = APIRouter(prefix="/api", tags=["Apply"])
+
+client = K8sClient()
+
+class ApplyRequest(BaseModel):
+    yaml: str
+
+class ApplyResponse(BaseModel):
+    success: bool
+    message: str
+    raw: str
+
+def inject_unique(yaml_text: str) -> str:
+    try:
+        obj = yaml.safe_load(yaml_text)
+        kind = obj.get("kind")
+
+        if kind in ["Job", "CronJob", "Deployment"]:
+            suffix = str(uuid.uuid4())[:5]
+            obj["metadata"]["name"] += f"-{suffix}"
+
+        return yaml.safe_dump(obj)
+    except:
+        return yaml_text
+
+@router.post("/apply", response_model=ApplyResponse)
+def apply_resource(req: ApplyRequest):
+    final_yaml = inject_unique(req.yaml)
+    result = client.apply_manifest(final_yaml)
+    raw = str(result.raw_response)
+    return ApplyResponse(success=result.success, message=result.message, raw=raw)

hf-space/backend/routers/logs.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+from agentctl.k8s_client import K8sClient
+
+router = APIRouter(prefix="/api", tags=["Logs"])
+
+client = K8sClient()
+
+@router.get("/logs")
+def get_logs(pod_name: str, tail: int = 100):
+    logs = client.get_pod_logs(pod_name, tail)
+    return {"pod": pod_name, "tail": tail, "logs": logs}

hf-space/backend/routers/snapshot.py

@@ -0,0 +1,19 @@
+from fastapi import APIRouter
+from agentctl.k8s_client import K8sClient
+
+router = APIRouter(prefix="/api", tags=["Snapshot"])
+
+client = K8sClient()
+
+@router.get("/snapshot")
+def snapshot():
+    snap = client.snapshot()
+
+    data = {
+        "namespace": snap.namespace,
+        "jobs": [vars(j) for j in snap.jobs],
+        "pods": [vars(p) for p in snap.pods],
+        "deployments": [vars(d) for d in snap.deployments],
+        "cronjobs": [vars(c) for c in snap.cronjobs],
+    }
+    return data

hf-space/backend/routers/yaml_gen.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+from agentctl.agent import K8sAgent
+from agentctl.config import settings
+
+router = APIRouter(prefix="/api", tags=["YAML Generation"])
+
+agent = K8sAgent()
+
+class GenerateRequest(BaseModel):
+    prompt: str
+    namespace: str | None = None
+    kind: str | None = "Auto"
+
+class GenerateResponse(BaseModel):
+    yaml: str
+
+@router.post("/generate-yaml", response_model=GenerateResponse)
+def generate_yaml(req: GenerateRequest):
+    ns = req.namespace or settings.k8s_namespace
+    kind = None if req.kind == "Auto" else req.kind
+    _, yaml_text = agent.nl_to_resource_yaml(req.prompt, ns, kind)
+    return GenerateResponse(yaml=yaml_text)

hf-space/backend/services/agent_service.py

@@ -0,0 +1,29 @@
+from agentctl.agent import K8sAgent
+from agentctl.config import settings
+
+
+class AgentService:
+    """
+    Wrapper for the LLM → YAML agent.
+    """
+
+    def __init__(self):
+        self.agent = K8sAgent()
+
+    def generate_yaml(self, prompt: str, namespace: str | None, kind: str | None):
+        # fallback to default namespace from config
+        ns = namespace or settings.k8s_namespace
+        kind_sel = None if (kind is None or kind == "Auto") else kind
+
+        # returns: (explanation, yaml_text)
+        _, yaml_text = self.agent.nl_to_resource_yaml(
+            prompt,
+            namespace=ns,
+            kind=kind_sel,
+        )
+
+        return yaml_text
+
+
+# Shared singleton
+agent_service = AgentService()

hf-space/backend/services/k8s_service.py

@@ -0,0 +1,28 @@
+from agentctl.k8s_client import K8sClient
+
+
+class K8sService:
+    """
+    Simple wrapper around your existing K8sClient.
+    This allows FastAPI routes to call Kubernetes operations
+    without importing K8sClient directly in every router.
+    """
+
+    def __init__(self):
+        self.client = K8sClient()
+
+    # ---- Apply YAML ----
+    def apply_manifest(self, yaml_text: str):
+        return self.client.apply_manifest(yaml_text)
+
+    # ---- Snapshot ----
+    def snapshot(self):
+        return self.client.snapshot()
+
+    # ---- Logs ----
+    def get_pod_logs(self, pod_name: str, tail_lines: int = 100):
+        return self.client.get_pod_logs(pod_name, tail_lines=tail_lines)
+
+
+# Shared singleton instance
+k8s_service = K8sService()

hf-space/hf-space/app.py

@@ -81,7 +81,6 @@ def apply_yaml_to_cluster(yaml_text: str) -> Tuple[str, str]:
     if not yaml_text.strip():
         return "No YAML to apply.", ""
 
-    # Add unique suffix before applying
     yaml_text = _inject_unique_name(yaml_text)
 
     client = _get_client()
@@ -229,9 +228,7 @@ def build_app() -> gr.Blocks:
 ---
 """)
 
-        # -----------------------------------------------------------------
         # Create Resource
-        # -----------------------------------------------------------------
         with gr.Tab("Create Resource"):
             with gr.Row():
                 prompt = gr.Textbox(
@@ -273,9 +270,7 @@ def build_app() -> gr.Blocks:
                 outputs=[apply_msg, apply_debug],
             )
 
-        # -----------------------------------------------------------------
         # Dashboard
-        # -----------------------------------------------------------------
         with gr.Tab("Cluster Dashboard"):
             snapshot_btn = gr.Button("Refresh snapshot", variant="primary")
             snapshot_box = gr.Textbox(lines=25, label="Cluster Overview")
@@ -286,9 +281,7 @@ def build_app() -> gr.Blocks:
                 outputs=snapshot_box,
             )
 
-        # -----------------------------------------------------------------
         # Logs
-        # -----------------------------------------------------------------
         with gr.Tab("Pod Logs"):
             pod_name = gr.Textbox(label="Pod name")
             tail_lines = gr.Slider(10, 500, step=10, value=100, label="Tail lines")
@@ -304,11 +297,11 @@ def build_app() -> gr.Blocks:
                 outputs=logs_box,
             )
 
+            # FIXED: removed `stream=True`
             follow_logs_btn.click(
                 follow_pod_logs,
                 inputs=[pod_name, tail_lines],
                 outputs=logs_box,
-                stream=True,
             )
 
     return demo

hf-space/hf-space/hf-space/hf-space/app.py

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 
 import os
+import re
+import time
+import uuid
+import yaml
 from typing import Tuple
 
 import gradio as gr
@@ -10,26 +14,66 @@ from agentctl.k8s_client import K8sClient
 from agentctl.agent import K8sAgent
 
 
-agent = K8sAgent()
+# ---------------------------------------------------------------------
+# Core - Agent + Client
+# ---------------------------------------------------------------------
 
+agent = K8sAgent()
 
 def _get_client() -> K8sClient:
     return K8sClient()
 
 
-# ------------------------------------------------------------
-# Handlers
-# ------------------------------------------------------------
+# ---------------------------------------------------------------------
+# Unique Name Injection
+# ---------------------------------------------------------------------
+
+def _inject_unique_name(yaml_text: str) -> str:
+    """
+    Add unique suffix to metadata.name for Job, Deployment, CronJob.
+    Prevents 409 AlreadyExists errors.
+    """
+    try:
+        data = yaml.safe_load(yaml_text)
+        if not isinstance(data, dict):
+            return yaml_text
+
+        kind = data.get("kind")
+        if kind not in {"Job", "CronJob", "Deployment"}:
+            return yaml_text
+
+        base = data["metadata"]["name"]
+        suffix = str(uuid.uuid4())[:5]
+        new_name = f"{base}-{suffix}"
+        data["metadata"]["name"] = new_name
+
+        # Patch CronJob template labels
+        if kind == "CronJob":
+            jt = data["spec"]["jobTemplate"]["spec"]["template"]
+            if "metadata" in jt:
+                if "labels" in jt["metadata"]:
+                    jt["metadata"]["labels"]["app"] = new_name
+                else:
+                    jt["metadata"]["labels"] = {"app": new_name}
+
+        return yaml.safe_dump(data)
+
+    except Exception:
+        return yaml_text
 
 
+# ---------------------------------------------------------------------
+# YAML Generation + Apply
+# ---------------------------------------------------------------------
+
 def generate_yaml_from_prompt(prompt: str, namespace: str, kind: str) -> str:
     if not prompt.strip():
         return "# Enter a description, e.g. 'run a python preprocessing job'"
-    _, yaml_text = agent.nl_to_resource_yaml(
-        prompt,
-        namespace=namespace or settings.k8s_namespace,
-        kind=kind if kind != "Auto" else None,
-    )
+
+    ns = namespace.strip() or settings.k8s_namespace
+    kind_sel = None if kind == "Auto" else kind
+
+    _, yaml_text = agent.nl_to_resource_yaml(prompt, namespace=ns, kind=kind_sel)
     return yaml_text
 
 
@@ -37,118 +81,173 @@ def apply_yaml_to_cluster(yaml_text: str) -> Tuple[str, str]:
     if not yaml_text.strip():
         return "No YAML to apply.", ""
 
+    # Add unique suffix before applying
+    yaml_text = _inject_unique_name(yaml_text)
+
     client = _get_client()
     result = client.apply_manifest(yaml_text)
 
-    if result.success:
-        return result.message, (result.raw_response and str(result.raw_response) or "")
-    else:
-        return f"❌ {result.message}", (result.raw_response and str(result.raw_response) or "")
+    try:
+        raw = str(result.raw_response)
+    except:
+        raw = "<unserialisable>"
+
+    prefix = "✅" if result.success else "❌"
+    return f"{prefix} {result.message}", raw
 
 
+# ---------------------------------------------------------------------
+# Cluster Snapshot
+# ---------------------------------------------------------------------
+
 def get_cluster_snapshot() -> str:
     client = _get_client()
     snap = client.snapshot()
 
-    lines: list[str] = [f"Namespace: {snap.namespace}", ""]
+    out = [f"Namespace: {snap.namespace}", ""]
 
-    # Jobs
-    lines.append("Jobs:")
+    out.append("Jobs:")
     if not snap.jobs:
-        lines.append("  (no jobs)")
+        out.append("  (no jobs)")
     else:
         for j in snap.jobs:
-            lines.append(
+            out.append(
                 f"  - {j.name}: succeeded={j.succeeded}, failed={j.failed}, active={j.active}"
             )
 
-    # Pods
-    lines.append("")
-    lines.append("Pods:")
+    out.append("")
+    out.append("Pods:")
     if not snap.pods:
-        lines.append("  (no pods)")
+        out.append("  (no pods)")
     else:
         for p in snap.pods:
-            lines.append(f"  - {p.name}: phase={p.phase}")
+            out.append(f"  - {p.name}: phase={p.phase}")
 
-    # Deployments
-    lines.append("")
-    lines.append("Deployments:")
+    out.append("")
+    out.append("Deployments:")
     if not snap.deployments:
-        lines.append("  (no deployments)")
+        out.append("  (no deployments)")
     else:
         for d in snap.deployments:
-            lines.append(
-                f"  - {d.name}: replicas={d.replicas}, ready={d.ready}"
-            )
+            out.append(f"  - {d.name}: replicas={d.replicas}, ready={d.ready}")
 
-    # CronJobs
-    lines.append("")
-    lines.append("CronJobs:")
+    out.append("")
+    out.append("CronJobs:")
     if not snap.cronjobs:
-        lines.append("  (no cronjobs)")
+        out.append("  (no cronjobs)")
     else:
         for c in snap.cronjobs:
             last = c.last_schedule or "never"
-            lines.append(
-                f"  - {c.name}: active={c.active}, lastScheduleTime={last}"
-            )
+            out.append(f"  - {c.name}: active={c.active}, lastScheduleTime={last}")
+
+    return "\n".join(out)
+
+
+# ---------------------------------------------------------------------
+# Logs System
+# ---------------------------------------------------------------------
+
+def _colorize_logs(text: str) -> str:
+    if not text:
+        return "<span style='color:#888;'>No logs</span>"
+
+    html_lines = []
+    for line in text.splitlines():
+        if re.search(r"(error|failed|exception)", line, re.IGNORECASE):
+            color = "#ff4b4b"
+        elif re.search(r"warn", line, re.IGNORECASE):
+            color = "#f7c843"
+        elif re.search(r"(info|started|running|completed)", line, re.IGNORECASE):
+            color = "#5ad55a"
+        else:
+            color = "#d0d0d0"
+
+        safe = line.replace("<", "&lt;").replace(">", "&gt;")
+        html_lines.append(f"<span style='color:{color};'>{safe}</span>")
+
+    return "<br>".join(html_lines)
 
-    return "\n".join(lines)
 
+def get_pod_logs_once(pod_name: str, tail_lines: int) -> str:
+    pod_name = pod_name.strip()
+    if not pod_name:
+        return "<span style='color:#ff4b4b;'>Enter a pod name.</span>"
 
-def get_pod_logs_handler(pod_name: str, tail_lines: int) -> str:
-    if not pod_name.strip():
-        return "Enter a pod name from the snapshot above."
     client = _get_client()
-    logs = client.get_pod_logs(pod_name.strip(), tail_lines=tail_lines)
-    return logs
+    raw = client.get_pod_logs(pod_name, tail_lines)
+    return _colorize_logs(raw)
 
 
-# ------------------------------------------------------------
-# Gradio UI
-# ------------------------------------------------------------
+def follow_pod_logs(pod_name: str, tail_lines: int):
+    pod_name = pod_name.strip()
+    if not pod_name:
+        yield "<span style='color:#ff4b4b;'>Enter a pod name.</span>"
+        return
 
+    client = _get_client()
+    while True:
+        raw = client.get_pod_logs(pod_name, tail_lines)
+        yield _colorize_logs(raw)
+        time.sleep(2)
+
+
+# ---------------------------------------------------------------------
+# Logs CSS
+# ---------------------------------------------------------------------
+
+TERMINAL_CSS = """
+#logs_terminal {
+    background-color: #111;
+    color: #ddd;
+    font-family: monospace;
+    padding: 14px;
+    border-radius: 8px;
+    border: 1px solid #444;
+    height: 420px;
+    overflow-y: scroll;
+    white-space: pre-wrap;
+}
+"""
+
+
+# ---------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------
 
 def build_app() -> gr.Blocks:
-    with gr.Blocks(title="AgentCTL: LLM-Driven Kubernetes Automation") as demo:
-        gr.Markdown(
-            """
-            # AgentCTL: LLM-Driven Kubernetes Automation
-
-            This Space connects to a **real Kubernetes cluster** (e.g. Minikube
-            exposed via `kubectl proxy` + ngrok). It demonstrates an
-            **agentic workflow** where natural language is converted into
-            Kubernetes Job / Deployment / CronJob manifests.
-
-            Environment variables:
-
-            - `K8S_API_BASE_URL` → public K8s API URL (ngrok over `kubectl proxy`)
-            - `K8S_NAMESPACE`    → default namespace
-            - `K8S_VERIFY_SSL`   → true/false
-            - `AGENTCTL_USE_LLM` → true/false (optional; uses OpenAI if enabled)
-            - `OPENAI_API_KEY`   → your key (if LLM enabled)
-            """
-        )
-
-        # --------- Create Resource tab --------- #
+    with gr.Blocks(
+        title="AgentCTL: LLM-Driven Kubernetes Automation",
+        css=TERMINAL_CSS,
+    ) as demo:
+
+        gr.Markdown("""
+### 🔧 Environment
+- `K8S_API_BASE_URL`  
+- `K8S_NAMESPACE`  
+- `K8S_VERIFY_SSL`  
+- `OPENAI_API_KEY` (optional)
+---
+""")
+
+        # -----------------------------------------------------------------
+        # Create Resource
+        # -----------------------------------------------------------------
         with gr.Tab("Create Resource"):
             with gr.Row():
                 prompt = gr.Textbox(
-                    label="Describe the resource you want",
+                    label="Describe the resource",
                     placeholder=(
-                        "Examples:\n"
-                        "- run a python job to preprocess data\n"
+                        "- run a python job\n"
                         "- create an nginx deployment with 3 replicas\n"
-                        "- schedule a python cleanup job every 5 minutes\n"
+                        "- schedule a cleanup script every 5 minutes\n"
                     ),
                     lines=5,
                 )
+
                 with gr.Column():
                     namespace = gr.Textbox(
-                        label="Kubernetes namespace",
+                        label="Namespace",
                         value=settings.k8s_namespace,
-                        lines=1,
                     )
                     kind = gr.Dropdown(
                         label="Resource kind",
@@ -156,50 +255,60 @@ def build_app() -> gr.Blocks:
                         value="Auto",
                     )
 
-            generate_btn = gr.Button("Generate YAML")
-            yaml_box = gr.Code(label="Generated Manifest (YAML)", language="yaml", lines=22)
+            generate_btn = gr.Button("Generate YAML", variant="primary")
+            yaml_box = gr.Code(language="yaml", lines=22, label="Generated YAML")
 
-            apply_btn = gr.Button("Apply to Cluster")
-            apply_msg = gr.Textbox(label="Status", interactive=False)
-            apply_raw = gr.Textbox(label="Raw API response (debug)")
+            apply_btn = gr.Button("Apply to cluster")
+            apply_msg = gr.Textbox(label="Status")
+            apply_debug = gr.Textbox(label="Raw API Response")
 
             generate_btn.click(
-                fn=generate_yaml_from_prompt,
+                generate_yaml_from_prompt,
                 inputs=[prompt, namespace, kind],
-                outputs=[yaml_box],
+                outputs=yaml_box,
             )
-
             apply_btn.click(
-                fn=apply_yaml_to_cluster,
+                apply_yaml_to_cluster,
                 inputs=[yaml_box],
-                outputs=[apply_msg, apply_raw],
+                outputs=[apply_msg, apply_debug],
             )
 
-        # --------- Dashboard tab --------- #
+        # -----------------------------------------------------------------
+        # Dashboard
+        # -----------------------------------------------------------------
         with gr.Tab("Cluster Dashboard"):
-            gr.Markdown("Snapshot of Jobs, Pods, Deployments and CronJobs in the namespace.")
-            snapshot_btn = gr.Button("Refresh snapshot")
-            snapshot_box = gr.Textbox(label="Cluster Overview", lines=25)
+            snapshot_btn = gr.Button("Refresh snapshot", variant="primary")
+            snapshot_box = gr.Textbox(lines=25, label="Cluster Overview")
 
-            snapshot_btn.click(fn=get_cluster_snapshot, inputs=[], outputs=[snapshot_box])
+            snapshot_btn.click(
+                get_cluster_snapshot,
+                inputs=[],
+                outputs=snapshot_box,
+            )
 
-        # --------- Pod Logs tab --------- #
+        # -----------------------------------------------------------------
+        # Logs
+        # -----------------------------------------------------------------
         with gr.Tab("Pod Logs"):
             pod_name = gr.Textbox(label="Pod name")
-            tail_lines = gr.Slider(
-                label="Tail lines",
-                minimum=10,
-                maximum=500,
-                step=10,
-                value=100,
+            tail_lines = gr.Slider(10, 500, step=10, value=100, label="Tail lines")
+
+            get_logs_btn = gr.Button("Get logs once")
+            follow_logs_btn = gr.Button("Follow logs (live)", variant="primary")
+
+            logs_box = gr.HTML(elem_id="logs_terminal", label="Logs")
+
+            get_logs_btn.click(
+                get_pod_logs_once,
+                inputs=[pod_name, tail_lines],
+                outputs=logs_box,
             )
-            logs_btn = gr.Button("Get logs")
-            logs_box = gr.Textbox(label="Logs", lines=25)
 
-            logs_btn.click(
-                fn=get_pod_logs_handler,
+            follow_logs_btn.click(
+                follow_pod_logs,
                 inputs=[pod_name, tail_lines],
-                outputs=[logs_box],
+                outputs=logs_box,
+                stream=True,
             )
 
     return demo
@@ -208,4 +317,5 @@ def build_app() -> gr.Blocks:
 app = build_app()
 
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))
+    port = int(os.getenv("PORT", "7860"))
+    app.launch(server_name="0.0.0.0", server_port=port)

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/.github/workflows/sync-to-hf.yml

@@ -0,0 +1,39 @@
+name: Sync GitHub (master) → Hugging Face Space (main)
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Sync files to Hugging Face Space
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          echo "🔐 Configuring Git"
+          git config --global user.email "actions@github.com"
+          git config --global user.name "GitHub Actions"
+
+          echo "📥 Cloning Hugging Face Space repo"
+          git clone https://codeninja3d:${HF_TOKEN}@huggingface.co/spaces/codeninja3d/agentctl hf-space
+
+          echo "📤 Syncing GitHub files → HF Space (rsync)"
+          rsync -av --delete --exclude=".git" ./ hf-space/ || true
+
+          cd hf-space
+
+          echo "📌 Committing changes"
+          git add .
+          git commit -m "Sync from GitHub on master ($(date))" || echo "No changes"
+
+          echo "⬆️ Pushing to Hugging Face Space (main branch)"
+          git push https://codeninja3d:${HF_TOKEN}@huggingface.co/spaces/codeninja3d/agentctl HEAD:main
+
+          echo "🎉 Sync complete!"

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/README.md

@@ -1,16 +1,225 @@
 ---
-title: AgentCTL
-emoji: ⚙️
+title: AgentCTL – Kubernetes Agent UI
+emoji: 🧠
 colorFrom: blue
-colorTo: purple
+colorTo: green
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: "4.42.0"
 app_file: app.py
 pinned: false
 ---
 
 
-AgentCTL is a next-generation, agentic control plane for Kubernetes.
-It allows you to create, manage, and observe Kubernetes resources using natural language, backed by a minimal REST client and optional LLM-powered YAML generation.
+# AgentCTL — LLM-Driven Kubernetes Automation  
+### Natural Language → Kubernetes Jobs, Deployments & CronJobs  
+Built for real clusters via Minikube + kubectl proxy + ngrok or Cloudflare Tunnel.
 
-AgentCTL runs locally or can be deployed to Hugging Face Spaces, allowing cloud-hosted UI + locally hosted Kubernetes clusters.
+---
+
+## 🚀 Overview
+
+**AgentCTL** is an agentic workflow system that converts **natural language instructions** into **Kubernetes manifests** (Jobs, Deployments, CronJobs) and applies them to a **real Kubernetes cluster**.
+
+It works by exposing your cluster via:
+
+- `kubectl proxy`
+- a public tunnel (`ngrok` or `cloudflared`)
+- a Gradio web UI  
+- a lightweight NL → YAML agent (heuristic + optional OpenAI LLM)
+
+---
+
+## ✨ Features
+
+- Natural language → Kubernetes YAML  
+- Supports:
+  - Jobs
+  - Deployments
+  - CronJobs  
+- Optional OpenAI LLM YAML refinement  
+- Cluster dashboard (Jobs, Pods, Deployments, CronJobs)  
+- Pod logs viewer  
+- Pure HTTP client — no kubeconfig required  
+
+---
+
+## 🧱 Architecture
+
+```
+Gradio UI → AgentCTL (NL→YAML) → K8sClient (HTTP) → Kubernetes API
+```
+
+---
+
+## 📦 Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+or
+
+```bash
+conda create -n agentctl python=3.10 -y
+conda activate agentctl
+pip install -r requirements.txt
+```
+
+---
+
+## 🧪 Minikube Setup
+
+```bash
+minikube start --driver=docker
+kubectl get pods -A
+```
+
+Expose API publicly:
+
+```bash
+kubectl proxy   --port=8001   --address=0.0.0.0   --accept-hosts='.*'   --accept-paths='.*'
+```
+
+Tunnel:
+
+```bash
+ngrok http 8001
+```
+
+---
+
+## 🌐 Environment Variables
+
+```bash
+export K8S_API_BASE_URL="https://xxxx.ngrok-free.dev"
+export K8S_NAMESPACE="default"
+export K8S_VERIFY_SSL=false
+```
+
+Enable LLM YAML:
+
+```bash
+export AGENTCTL_USE_LLM=true
+export OPENAI_API_KEY="sk-..."
+export OPENAI_MODEL="gpt-4o-mini"
+```
+
+---
+
+## ▶️ Run the App
+
+```bash
+python app.py
+```
+
+Open:
+
+```
+http://localhost:7860
+```
+
+---
+
+## 📝 Usage Examples
+
+### 🟦 Job
+```
+run a python job to preprocess data
+```
+
+### 🟧 Deployment
+```
+Prompt
+create an nginx deployment with 3 replicas
+
+Example
+**Generated YAML:**
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx-deployment
+  namespace: default
+  labels:
+    app: agentctl-deployment
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: agentctl-deployment
+  template:
+    metadata:
+      labels:
+        app: agentctl-deployment
+    spec:
+      containers:
+        - name: main
+          image: nginx:1.27-alpine
+          ports:
+            - containerPort: 80
+
+```
+
+### 🟩 CronJob
+```
+Prompt
+schedule a python cleanup script every 5 minutes
+
+example
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: agentctl-cronjob
+  namespace: default
+spec:
+  schedule: "*/5 * * * *"
+  jobTemplate:
+    spec:
+      template:
+        metadata:
+          labels:
+            app: agentctl-cronjob
+        spec:
+          restartPolicy: Never
+          containers:
+            - name: main
+              image: python:3.11-slim
+              command:
+                - /bin/sh
+                - -c
+                - python cleanup.py
+
+```
+
+---
+
+## 🚀 Deploy to Hugging Face Spaces
+
+1. Create a Space (Gradio)
+2. Upload project files
+3. Set environment variables
+4. Run the UI remotely controlling your real cluster
+
+---
+
+## 🔐 Security Notes
+
+- ngrok + kubectl proxy is for demos only  
+- For real environments use:
+  - Cloudflare Tunnel  
+  - RBAC service accounts  
+  - Namespaced permissions  
+
+---
+
+## ❤️ Credits
+
+Built by **Murali Chandran (codeninja3d)**  
+AI Agents • Kubernetes • MLOps
+
+---
+
+## 📄 License
+
+MIT License

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/app.py

@@ -1,8 +1,6 @@
 #!/usr/bin/env python3
 
 import os
-import re
-import time
 from typing import Tuple
 
 import gradio as gr
@@ -12,65 +10,43 @@ from agentctl.k8s_client import K8sClient
 from agentctl.agent import K8sAgent
 
 
-# ---------------------------------------------------------------------
-# Core objects
-# ---------------------------------------------------------------------
-
 agent = K8sAgent()
 
 
 def _get_client() -> K8sClient:
-    """Create a Kubernetes HTTP client using env-based config."""
     return K8sClient()
 
 
-# ---------------------------------------------------------------------
-# YAML generation + apply
-# ---------------------------------------------------------------------
+# ------------------------------------------------------------
+# Handlers
+# ------------------------------------------------------------
 
 
 def generate_yaml_from_prompt(prompt: str, namespace: str, kind: str) -> str:
-    """Convert natural language + kind selection into YAML."""
     if not prompt.strip():
         return "# Enter a description, e.g. 'run a python preprocessing job'"
-
-    ns = namespace.strip() or settings.k8s_namespace
-    kind_sel = None if kind == "Auto" else kind
-
     _, yaml_text = agent.nl_to_resource_yaml(
         prompt,
-        namespace=ns,
-        kind=kind_sel,
+        namespace=namespace or settings.k8s_namespace,
+        kind=kind if kind != "Auto" else None,
     )
     return yaml_text
 
 
 def apply_yaml_to_cluster(yaml_text: str) -> Tuple[str, str]:
-    """Apply a YAML manifest to the cluster via K8s API."""
     if not yaml_text.strip():
         return "No YAML to apply.", ""
 
     client = _get_client()
     result = client.apply_manifest(yaml_text)
 
-    raw_str = ""
-    if result.raw_response is not None:
-        try:
-            raw_str = str(result.raw_response)
-        except Exception:
-            raw_str = "<unserialisable response>"
-
-    prefix = "✅" if result.success else "❌"
-    return f"{prefix} {result.message}", raw_str
-
-
-# ---------------------------------------------------------------------
-# Dashboard snapshot
-# ---------------------------------------------------------------------
+    if result.success:
+        return result.message, (result.raw_response and str(result.raw_response) or "")
+    else:
+        return f"❌ {result.message}", (result.raw_response and str(result.raw_response) or "")
 
 
 def get_cluster_snapshot() -> str:
-    """Return a human-readable snapshot of Jobs, Pods, Deployments, CronJobs."""
     client = _get_client()
     snap = client.snapshot()
 
@@ -83,8 +59,7 @@ def get_cluster_snapshot() -> str:
     else:
         for j in snap.jobs:
             lines.append(
-                f"  - {j.name}: succeeded={j.succeeded}, "
-                f"failed={j.failed}, active={j.active}"
+                f"  - {j.name}: succeeded={j.succeeded}, failed={j.failed}, active={j.active}"
             )
 
     # Pods
@@ -122,109 +97,41 @@ def get_cluster_snapshot() -> str:
     return "\n".join(lines)
 
 
-# ---------------------------------------------------------------------
-# Logs helpers (colorised terminal + live follow)
-# ---------------------------------------------------------------------
+def get_pod_logs_handler(pod_name: str, tail_lines: int) -> str:
+    if not pod_name.strip():
+        return "Enter a pod name from the snapshot above."
+    client = _get_client()
+    logs = client.get_pod_logs(pod_name.strip(), tail_lines=tail_lines)
+    return logs
 
 
-def _fetch_pod_logs_raw(pod_name: str, tail_lines: int) -> str:
-    """Internal: raw log text from Kubernetes."""
-    client = _get_client()
-    return client.get_pod_logs(pod_name.strip(), tail_lines=tail_lines)
-
-
-def _colorize_logs(text: str) -> str:
-    """Convert log text into HTML with basic severity colouring."""
-    if not text:
-        return "<span style='color:#888;'>No logs</span>"
-
-    lines = text.splitlines()
-    out: list[str] = []
-
-    for line in lines:
-        if re.search(r"(error|failed|exception)", line, re.IGNORECASE):
-            colour = "#ff4b4b"  # red
-        elif re.search(r"(warn)", line, re.IGNORECASE):
-            colour = "#f7c843"  # yellow
-        elif re.search(r"(info|started|running|completed)", line, re.IGNORECASE):
-            colour = "#5ad55a"  # green
-        else:
-            colour = "#d0d0d0"  # grey
-
-        safe = line.replace("<", "&lt;").replace(">", "&gt;")
-        out.append(f"<span style='color:{colour};'>{safe}</span>")
-
-    return "<br>".join(out)
-
-
-def get_pod_logs_once(pod_name: str, tail_lines: int) -> str:
-    """One-shot logs fetch, used for the 'Get logs' button."""
-    pod_name = pod_name.strip()
-    if not pod_name:
-        return "<span style='color:#ff4b4b;'>Enter a pod name from the dashboard.</span>"
-
-    raw = _fetch_pod_logs_raw(pod_name, tail_lines)
-    return _colorize_logs(raw)
-
-
-def follow_pod_logs(pod_name: str, tail_lines: int):
-    """Live streaming logs using Gradio generator output."""
-    pod_name = pod_name.strip()
-    if not pod_name:
-        yield "<span style='color:#ff4b4b;'>Enter a pod name from the dashboard.</span>"
-        return
-
-    while True:
-        raw = _fetch_pod_logs_raw(pod_name, tail_lines)
-        html = _colorize_logs(raw)
-        yield html
-        time.sleep(2)
-
-
-# CSS for the logs "terminal"
-TERMINAL_CSS = """
-#logs_terminal {
-    background-color: #111111 !important;
-    color: #d0d0d0 !important;
-    font-family: monospace !important;
-    padding: 14px;
-    border-radius: 8px;
-    border: 1px solid #444444;
-    height: 420px;
-    overflow-y: scroll;
-    white-space: pre-wrap;
-}
-"""
-
-
-# ---------------------------------------------------------------------
+# ------------------------------------------------------------
 # Gradio UI
-# ---------------------------------------------------------------------
+# ------------------------------------------------------------
 
 
 def build_app() -> gr.Blocks:
-    with gr.Blocks(
-        title="AgentCTL: LLM-Driven Kubernetes Automation",
-        css=TERMINAL_CSS,
-    ) as demo:
-        # Top environment hint (like your screenshot)
+    with gr.Blocks(title="AgentCTL: LLM-Driven Kubernetes Automation") as demo:
         gr.Markdown(
             """
-### 🔧 Environment configuration
+            # AgentCTL: LLM-Driven Kubernetes Automation
+
+            This Space connects to a **real Kubernetes cluster** (e.g. Minikube
+            exposed via `kubectl proxy` + ngrok). It demonstrates an
+            **agentic workflow** where natural language is converted into
+            Kubernetes Job / Deployment / CronJob manifests.
 
-- `K8S_API_BASE_URL` → **public K8s API URL** (ngrok / Cloudflare tunnel over `kubectl proxy`)
-- `K8S_NAMESPACE` → **default namespace** (e.g. `default`)
-- `K8S_VERIFY_SSL` → **true/false** (set `false` for self-signed ngrok endpoints)
-- `AGENTCTL_USE_LLM` → **true/false** (optional; uses OpenAI if enabled in `agent.py`)
-- `OPENAI_API_KEY` → your key (if LLM mode enabled)
+            Environment variables:
 
----
-"""
+            - `K8S_API_BASE_URL` → public K8s API URL (ngrok over `kubectl proxy`)
+            - `K8S_NAMESPACE`    → default namespace
+            - `K8S_VERIFY_SSL`   → true/false
+            - `AGENTCTL_USE_LLM` → true/false (optional; uses OpenAI if enabled)
+            - `OPENAI_API_KEY`   → your key (if LLM enabled)
+            """
         )
 
-        # ============================================================
-        # Create Resource tab
-        # ============================================================
+        # --------- Create Resource tab --------- #
         with gr.Tab("Create Resource"):
             with gr.Row():
                 prompt = gr.Textbox(
@@ -237,7 +144,6 @@ def build_app() -> gr.Blocks:
                     ),
                     lines=5,
                 )
-
                 with gr.Column():
                     namespace = gr.Textbox(
                         label="Kubernetes namespace",
@@ -249,25 +155,18 @@ def build_app() -> gr.Blocks:
                         choices=["Auto", "Job", "Deployment", "CronJob"],
                         value="Auto",
                     )
-                    gr.Markdown(
-                        "Tip: leave **Auto** to let the agent infer Job vs Deployment vs CronJob."
-                    )
 
-            generate_btn = gr.Button("Generate YAML", variant="primary")
-            yaml_box = gr.Code(
-                label="Generated manifest (YAML)",
-                language="yaml",
-                lines=22,
-            )
+            generate_btn = gr.Button("Generate YAML")
+            yaml_box = gr.Code(label="Generated Manifest (YAML)", language="yaml", lines=22)
 
-            apply_btn = gr.Button("Apply to cluster")
+            apply_btn = gr.Button("Apply to Cluster")
             apply_msg = gr.Textbox(label="Status", interactive=False)
             apply_raw = gr.Textbox(label="Raw API response (debug)")
 
             generate_btn.click(
                 fn=generate_yaml_from_prompt,
                 inputs=[prompt, namespace, kind],
-                outputs=yaml_box,
+                outputs=[yaml_box],
             )
 
             apply_btn.click(
@@ -276,39 +175,17 @@ def build_app() -> gr.Blocks:
                 outputs=[apply_msg, apply_raw],
             )
 
-        # ============================================================
-        # Cluster Dashboard tab
-        # ============================================================
+        # --------- Dashboard tab --------- #
         with gr.Tab("Cluster Dashboard"):
-            gr.Markdown(
-                "Snapshot of **Jobs, Pods, Deployments, CronJobs** in the target namespace."
-            )
-            snapshot_btn = gr.Button("Refresh snapshot", variant="primary")
-            snapshot_box = gr.Textbox(
-                label="Cluster overview",
-                lines=25,
-                interactive=False,
-            )
+            gr.Markdown("Snapshot of Jobs, Pods, Deployments and CronJobs in the namespace.")
+            snapshot_btn = gr.Button("Refresh snapshot")
+            snapshot_box = gr.Textbox(label="Cluster Overview", lines=25)
 
-            snapshot_btn.click(
-                fn=get_cluster_snapshot,
-                inputs=[],
-                outputs=[snapshot_box],
-            )
+            snapshot_btn.click(fn=get_cluster_snapshot, inputs=[], outputs=[snapshot_box])
 
-        # ============================================================
-        # Pod Logs tab
-        # ============================================================
+        # --------- Pod Logs tab --------- #
         with gr.Tab("Pod Logs"):
-            gr.Markdown(
-                "Paste a pod name from the **Cluster Dashboard** (e.g. `agentctl-job-lnrcp`) "
-                "and fetch its logs. Use **Follow logs** for a live `kubectl logs -f` style view."
-            )
-
-            pod_name = gr.Textbox(
-                label="Pod name",
-                placeholder="e.g. preprocess-job-z48rz",
-            )
+            pod_name = gr.Textbox(label="Pod name")
             tail_lines = gr.Slider(
                 label="Tail lines",
                 minimum=10,
@@ -316,24 +193,14 @@ def build_app() -> gr.Blocks:
                 step=10,
                 value=100,
             )
+            logs_btn = gr.Button("Get logs")
+            logs_box = gr.Textbox(label="Logs", lines=25)
 
-            with gr.Row():
-                get_logs_btn = gr.Button("Get logs once")
-                follow_logs_btn = gr.Button("Follow logs (live)", variant="primary")
-
-            logs_box = gr.HTML(label="Logs", elem_id="logs_terminal")
-
-            get_logs_btn.click(
-                fn=get_pod_logs_once,
+            logs_btn.click(
+                fn=get_pod_logs_handler,
                 inputs=[pod_name, tail_lines],
                 outputs=[logs_box],
             )
-            
-            follow_logs_btn.click(
-                fn=follow_pod_logs,
-                inputs=[pod_name, tail_lines],
-                outputs=logs_box,
-            )
 
     return demo
 
@@ -341,5 +208,4 @@ def build_app() -> gr.Blocks:
 app = build_app()
 
 if __name__ == "__main__":
-    port = int(os.getenv("PORT", "7860"))
-    app.launch(server_name="0.0.0.0", server_port=port)
+    app.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/.gitignore

@@ -0,0 +1,97 @@
+# --- Python ---
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.pkl
+*.pyd
+*.so
+
+# Virtual environment
+.venv/
+env/
+venv/
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb
+
+# --- OS files ---
+.DS_Store
+Thumbs.db
+
+# --- VSCode / JetBrains ---
+.vscode/
+.idea/
+
+# --- Logs ---
+*.log
+logs/
+*.out
+*.err
+
+# --- Build / Packaging ---
+build/
+dist/
+*.egg-info/
+.eggs/
+
+# --- Cache ---
+.cache/
+*.cache
+*.mypy_cache/
+*.pytest_cache/
+*.ruff_cache/
+
+# --- Hugging Face / HF Spaces ---
+hf_cache/
+huggingface/
+.environment/
+
+# --- Temp artifacts ---
+tmp/
+temp/
+*.tmp
+
+# --- Credentials / secrets (DO NOT COMMIT) ---
+.env
+.env.local
+.env.*        # safe because no secrets go into repo
+secrets.yml
+*.json.secret
+*.key
+*.pem
+
+# --- Kubernetes ---
+# kubeconfigs or kube generated files
+kubeconfig
+.kube/
+*.yaml.bak
+*~    # backups
+
+# --- Models / Checkpoints ---
+*.pt
+*.bin
+*.onnx
+models/
+checkpoints/
+
+# --- Node (if future UI additions) ---
+node_modules/
+npm-debug.log*
+
+# --- Gradio ---
+gradio_cached_examples/
+
+# --- Ngrok (just in case) ---
+ngrok.yml
+.ngrok/
+
+# --- Minikube artifacts ---
+minikube/
+.kubectl-proxy/
+
+
+# Block OpenAI keys if accidentally named
+openai_key.txt
+openai_api_key.txt

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/README.md

@@ -0,0 +1,16 @@
+---
+title: AgentCTL
+emoji: ⚙️
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
+pinned: false
+---
+
+
+AgentCTL is a next-generation, agentic control plane for Kubernetes.
+It allows you to create, manage, and observe Kubernetes resources using natural language, backed by a minimal REST client and optional LLM-powered YAML generation.
+
+AgentCTL runs locally or can be deployed to Hugging Face Spaces, allowing cloud-hosted UI + locally hosted Kubernetes clusters.

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/__init__.py

@@ -0,0 +1 @@
+__all__ = ["config", "k8s_client", "agent", "schemas"]

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/agent.py

@@ -0,0 +1,297 @@
+"""Natural language → Kubernetes YAML generator (Job / Deployment / CronJob).
+
+Heuristic templates + optional LLM (OpenAI) for richer YAML.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Tuple
+import os
+import re
+
+# Optional LLM support (OpenAI)
+try:
+    from openai import OpenAI  # pip install openai
+except Exception:  # pragma: no cover
+    OpenAI = None  # type: ignore
+
+
+@dataclass
+class JobSpecRequest:
+    prompt: str
+    name: str = "agentctl-job"
+    image: str = "busybox:1.36"
+    command: Optional[str] = "echo Hello && sleep 5"
+    cpu: str = "500m"
+    memory: str = "512Mi"
+    namespace: str = "default"
+
+
+class K8sAgent:
+    """Agent that turns NL into Job / Deployment / CronJob YAML."""
+
+    # --------------------- Kind detection --------------------- #
+
+    def infer_kind(self, text: str) -> str:
+        t = text.lower()
+
+        # CronJob-ish language
+        if any(w in t for w in ["every minute", "every 5 minutes", "every hour", "cron", "schedule", "scheduled job"]):
+            return "CronJob"
+
+        # Deployment-ish language
+        if any(w in t for w in ["deployment", "service", "web", "api", "server", "nginx", "frontend", "backend"]):
+            return "Deployment"
+
+        # Default to Job
+        return "Job"
+
+    # --------------------- Job templates --------------------- #
+
+    def nl_to_job_request(self, text: str, namespace: str = "default") -> JobSpecRequest:
+        t = text.lower()
+        name = "agentctl-job"
+
+        if "preprocess" in t:
+            name = "preprocess-job"
+        elif "inference" in t:
+            name = "inference-job"
+        elif "train" in t or "training" in t:
+            name = "training-job"
+
+        image = "busybox:1.36"
+        if "python" in t:
+            image = "python:3.11-slim"
+        if "pytorch" in t:
+            image = "pytorch/pytorch:2.3.0-cuda12.1-cudnn9-runtime"
+
+        command = "echo Hello && sleep 5"
+        if "run python" in t:
+            idx = t.find("run python")
+            if idx != -1:
+                # everything from "python" onwards becomes the command
+                fragment = text[idx:].replace("run ", "").strip()
+                command = fragment
+
+        cpu = "500m"
+        memory = "512Mi"
+        if "gpu" in t:
+            cpu = "2000m"
+            memory = "8Gi"
+
+        return JobSpecRequest(
+            prompt=text,
+            name=name,
+            image=image,
+            command=command,
+            cpu=cpu,
+            memory=memory,
+            namespace=namespace,
+        )
+
+    def job_request_to_yaml(self, req: JobSpecRequest) -> str:
+        cmd = ["/bin/sh", "-c", req.command] if req.command else None
+
+        lines = [
+            "apiVersion: batch/v1",
+            "kind: Job",
+            "metadata:",
+            f"  name: {req.name}",
+            f"  namespace: {req.namespace}",
+            "spec:",
+            "  template:",
+            "    metadata:",
+            "      labels:",
+            "        app: agentctl",
+            "    spec:",
+            "      restartPolicy: Never",
+            "      containers:",
+            "        - name: main",
+            f"          image: {req.image}",
+        ]
+        if cmd:
+            lines.append("          command:")
+            for c in cmd:
+                lines.append(f"            - {c}")
+        lines.extend(
+            [
+                "          resources:",
+                "            requests:",
+                f"              cpu: {req.cpu}",
+                f"              memory: {req.memory}",
+                "            limits:",
+                f"              cpu: {req.cpu}",
+                f"              memory: {req.memory}",
+            ]
+        )
+        return "\n".join(lines) + "\n"
+
+    # --------------------- Deployment template --------------------- #
+
+    def nl_to_deployment_yaml(self, text: str, namespace: str = "default") -> str:
+        t = text.lower()
+        name = "agentctl-deployment"
+        image = "nginx:1.27-alpine"
+        replicas = 1
+
+        if "nginx" in t:
+            name = "nginx-deployment"
+        if "python" in t:
+            image = "python:3.11-slim"
+        if "pytorch" in t:
+            image = "pytorch/pytorch:2.3.0-cuda12.1-cudnn9-runtime"
+
+        m = re.search(r"(\d+)\s+replica", t)
+        if m:
+            replicas = int(m.group(1))
+
+        lines = [
+            "apiVersion: apps/v1",
+            "kind: Deployment",
+            "metadata:",
+            f"  name: {name}",
+            f"  namespace: {namespace}",
+            "  labels:",
+            "    app: agentctl-deployment",
+            "spec:",
+            f"  replicas: {replicas}",
+            "  selector:",
+            "    matchLabels:",
+            "      app: agentctl-deployment",
+            "  template:",
+            "    metadata:",
+            "      labels:",
+            "        app: agentctl-deployment",
+            "    spec:",
+            "      containers:",
+            "        - name: main",
+            f"          image: {image}",
+            "          ports:",
+            "            - containerPort: 80",
+        ]
+        return "\n".join(lines) + "\n"
+
+    # --------------------- CronJob template --------------------- #
+
+    def nl_to_cronjob_yaml(self, text: str, namespace: str = "default") -> str:
+        t = text.lower()
+        name = "agentctl-cronjob"
+        image = "busybox:1.36"
+        command = "echo Hello from CronJob && date"
+        schedule = "*/5 * * * *"  # default every 5 minutes
+
+        if "every minute" in t:
+            schedule = "* * * * *"
+        elif "every 5 minutes" in t:
+            schedule = "*/5 * * * *"
+        elif "every hour" in t:
+            schedule = "0 * * * *"
+        elif "every day" in t:
+            schedule = "0 0 * * *"
+
+        if "python" in t:
+            image = "python:3.11-slim"
+        if "run python" in t:
+            idx = t.find("run python")
+            fragment = text[idx:].replace("run ", "").strip()
+            command = fragment
+
+        lines = [
+            "apiVersion: batch/v1",
+            "kind: CronJob",
+            "metadata:",
+            f"  name: {name}",
+            f"  namespace: {namespace}",
+            "spec:",
+            f"  schedule: \"{schedule}\"",
+            "  jobTemplate:",
+            "    spec:",
+            "      template:",
+            "        metadata:",
+            "          labels:",
+            "            app: agentctl-cronjob",
+            "        spec:",
+            "          restartPolicy: Never",
+            "          containers:",
+            "            - name: main",
+            f"              image: {image}",
+            "              command:",
+            "                - /bin/sh",
+            "                - -c",
+            f"                - {command}",
+        ]
+        return "\n".join(lines) + "\n"
+
+    # --------------------- Optional OpenAI LLM --------------------- #
+
+    def maybe_llm_yaml(self, text: str, kind: str, namespace: str, fallback_yaml: str) -> str:
+        """If AGENTCTL_USE_LLM=true and OpenAI is configured, ask the LLM
+        to generate/clean YAML. Otherwise return fallback_yaml.
+        """
+        use_llm = os.getenv("AGENTCTL_USE_LLM", "false").lower() == "true"
+        api_key = os.getenv("OPENAI_API_KEY")
+
+        if not use_llm or not api_key or OpenAI is None:
+            return fallback_yaml
+
+        client = OpenAI(api_key=api_key)
+        model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+        system_msg = (
+            "You are an expert Kubernetes engineer. "
+            "Given a natural language request, output a single valid Kubernetes "
+            f"{kind} manifest in YAML. Do not include explanations or code fences."
+        )
+
+        user_msg = (
+            f"Namespace: {namespace}\n"
+            f"Kind: {kind}\n"
+            f"Request: {text}\n\n"
+            "Start from this template and improve it if needed:\n"
+            f"{fallback_yaml}"
+        )
+
+        resp = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system_msg},
+                {"role": "user", "content": user_msg},
+            ],
+            temperature=0.1,
+        )
+        content = resp.choices[0].message.content or fallback_yaml
+
+        # Strip ```yaml fences if present
+        content = content.strip()
+        if content.startswith("```"):
+            content = re.sub(r"^```[a-zA-Z]*", "", content).strip()
+            if content.endswith("```"):
+                content = content[:-3].strip()
+
+        return content
+
+    # --------------------- Public entrypoint --------------------- #
+
+    def nl_to_resource_yaml(
+        self,
+        text: str,
+        namespace: str = "default",
+        kind: Optional[str] = None,
+    ) -> Tuple[str, str]:
+        """Return (kind, yaml) for a given prompt."""
+        if not kind or kind.lower() == "auto":
+            kind = self.infer_kind(text)
+
+        if kind == "Job":
+            req = self.nl_to_job_request(text, namespace)
+            base_yaml = self.job_request_to_yaml(req)
+        elif kind == "Deployment":
+            base_yaml = self.nl_to_deployment_yaml(text, namespace)
+        elif kind == "CronJob":
+            base_yaml = self.nl_to_cronjob_yaml(text, namespace)
+        else:
+            raise ValueError(f"Unsupported kind: {kind}")
+
+        final_yaml = self.maybe_llm_yaml(text, kind=kind, namespace=namespace, fallback_yaml=base_yaml)
+        return kind, final_yaml

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/config.py

@@ -0,0 +1,11 @@
+import os
+from dataclasses import dataclass
+
+@dataclass
+class Settings:
+    k8s_api_base_url: str = os.getenv("K8S_API_BASE_URL", "")
+    k8s_namespace: str = os.getenv("K8S_NAMESPACE", "default")
+    verify_ssl: bool = os.getenv("K8S_VERIFY_SSL", "false").lower() == "true"
+    k8s_bearer_token: str | None = os.getenv("K8S_BEARER_TOKEN") or None
+
+settings = Settings()

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/k8s_client.py

@@ -0,0 +1,209 @@
+"""Minimal Kubernetes HTTP client using the public API exposed via ngrok."""
+
+from __future__ import annotations
+
+import json
+from typing import Dict, Any, List
+
+import requests
+import yaml
+
+from .config import settings
+from .schemas import (
+    ApplyResult,
+    JobStatus,
+    PodInfo,
+    ClusterSnapshot,
+    DeploymentStatus,
+    CronJobStatus,
+)
+
+
+class K8sClient:
+    def __init__(self, base_url: str | None = None, namespace: str | None = None):
+        if not base_url:
+            base_url = settings.k8s_api_base_url
+        if not base_url:
+            raise ValueError("K8S_API_BASE_URL is not set. Configure it in env.")
+
+        self.base_url = base_url.rstrip("/")
+        self.namespace = namespace or settings.k8s_namespace
+        self.verify_ssl = settings.verify_ssl
+        self.bearer_token = settings.k8s_bearer_token
+
+    # ------------------------------------------------------------------ #
+    # Internal helpers                                                   #
+    # ------------------------------------------------------------------ #
+
+    def _headers(self) -> Dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.bearer_token:
+            headers["Authorization"] = f"Bearer {self.bearer_token}"
+        return headers
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        json_body: Dict[str, Any] | None = None,
+    ) -> requests.Response:
+        url = f"{self.base_url}{path}"
+        resp = requests.request(
+            method=method,
+            url=url,
+            headers=self._headers(),
+            json=json_body,
+            verify=self.verify_ssl,
+            timeout=30,
+        )
+        return resp
+
+    # ------------------------------------------------------------------ #
+    # Apply a manifest (Job / Deployment / CronJob)                      #
+    # ------------------------------------------------------------------ #
+
+    def apply_manifest(self, manifest_yaml: str) -> ApplyResult:
+        """Create a resource (Job / Deployment / CronJob) from YAML."""
+        try:
+            manifest = yaml.safe_load(manifest_yaml)
+        except yaml.YAMLError as e:
+            return ApplyResult(success=False, message=f"Invalid YAML: {e}")
+
+        if not isinstance(manifest, dict):
+            return ApplyResult(success=False, message="Manifest must be a single YAML object.")
+
+        kind = manifest.get("kind")
+        metadata = manifest.get("metadata", {})
+        name = metadata.get("name", "<unnamed>")
+        namespace = metadata.get("namespace", self.namespace)
+
+        if kind == "Job":
+            path = f"/apis/batch/v1/namespaces/{namespace}/jobs"
+        elif kind == "Deployment":
+            path = f"/apis/apps/v1/namespaces/{namespace}/deployments"
+        elif kind == "CronJob":
+            path = f"/apis/batch/v1/namespaces/{namespace}/cronjobs"
+        else:
+            return ApplyResult(success=False, message=f"Unsupported kind: {kind}")
+
+        resp = self._request("POST", path, json_body=manifest)
+
+        try:
+            raw = resp.json()
+        except json.JSONDecodeError:
+            raw = {"raw_text": resp.text}
+
+        if resp.status_code in (200, 201):
+            return ApplyResult(
+                success=True,
+                message=f"Created {kind} '{name}' in ns '{namespace}'.",
+                raw_response=raw,
+            )
+
+        return ApplyResult(
+            success=False,
+            message=f"K8s API error {resp.status_code}: {raw}",
+            raw_response=raw,
+        )
+
+    # ------------------------------------------------------------------ #
+    # List helpers for dashboard                                         #
+    # ------------------------------------------------------------------ #
+
+    def list_jobs(self) -> List[JobStatus]:
+        path = f"/apis/batch/v1/namespaces/{self.namespace}/jobs"
+        resp = self._request("GET", path)
+        data = resp.json()
+        items = data.get("items", [])
+        jobs: List[JobStatus] = []
+        for item in items:
+            meta = item.get("metadata", {})
+            status = item.get("status", {})
+            jobs.append(
+                JobStatus(
+                    name=meta.get("name", "<unknown>"),
+                    namespace=meta.get("namespace", self.namespace),
+                    succeeded=status.get("succeeded", 0) or 0,
+                    failed=status.get("failed", 0) or 0,
+                    active=status.get("active", 0) or 0,
+                )
+            )
+        return jobs
+
+    def list_pods(self) -> List[PodInfo]:
+        path = f"/api/v1/namespaces/{self.namespace}/pods"
+        resp = self._request("GET", path)
+        data = resp.json()
+        items = data.get("items", [])
+        pods: List[PodInfo] = []
+        for item in items:
+            meta = item.get("metadata", {})
+            status = item.get("status", {})
+            pods.append(
+                PodInfo(
+                    name=meta.get("name", "<unknown>"),
+                    phase=status.get("phase", "Unknown"),
+                    node_name=status.get("nodeName"),
+                )
+            )
+        return pods
+
+    def list_deployments(self) -> List[DeploymentStatus]:
+        path = f"/apis/apps/v1/namespaces/{self.namespace}/deployments"
+        resp = self._request("GET", path)
+        data = resp.json()
+        items = data.get("items", [])
+        out: List[DeploymentStatus] = []
+        for item in items:
+            meta = item.get("metadata", {})
+            st = item.get("status", {})
+            out.append(
+                DeploymentStatus(
+                    name=meta.get("name", "<unknown>"),
+                    namespace=meta.get("namespace", self.namespace),
+                    replicas=st.get("replicas", 0) or 0,
+                    ready=st.get("readyReplicas", 0) or 0,
+                )
+            )
+        return out
+
+    def list_cronjobs(self) -> List[CronJobStatus]:
+        path = f"/apis/batch/v1/namespaces/{self.namespace}/cronjobs"
+        resp = self._request("GET", path)
+        data = resp.json()
+        items = data.get("items", [])
+        out: List[CronJobStatus] = []
+        for item in items:
+            meta = item.get("metadata", {})
+            st = item.get("status", {})
+            last = st.get("lastScheduleTime")
+            out.append(
+                CronJobStatus(
+                    name=meta.get("name", "<unknown>"),
+                    namespace=meta.get("namespace", self.namespace),
+                    active=len(st.get("active", []) or []),
+                    last_schedule=str(last) if last is not None else None,
+                )
+            )
+        return out
+
+    def get_pod_logs(self, pod_name: str, container: str | None = None, tail_lines: int = 100) -> str:
+        params = {"tailLines": str(tail_lines)}
+        if container:
+            params["container"] = container
+
+        path = f"/api/v1/namespaces/{self.namespace}/pods/{pod_name}/log"
+        url = f"{self.base_url}{path}"
+        resp = requests.get(url, headers=self._headers(), params=params, verify=self.verify_ssl, timeout=30)
+        if resp.status_code == 200:
+            return resp.text
+        return f"Error {resp.status_code}: {resp.text}"
+
+    def snapshot(self) -> ClusterSnapshot:
+        return ClusterSnapshot(
+            namespace=self.namespace,
+            jobs=self.list_jobs(),
+            pods=self.list_pods(),
+            deployments=self.list_deployments(),
+            cronjobs=self.list_cronjobs(),
+        )

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/schemas.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+
+
+class ApplyResult(BaseModel):
+    success: bool
+    message: str
+    raw_response: Optional[Dict[str, Any]] = None
+
+
+class JobStatus(BaseModel):
+    name: str
+    namespace: str
+    succeeded: int = 0
+    failed: int = 0
+    active: int = 0
+
+
+class PodInfo(BaseModel):
+    name: str
+    phase: str
+    node_name: Optional[str] = None
+
+
+class DeploymentStatus(BaseModel):
+    name: str
+    namespace: str
+    replicas: int = 0
+    ready: int = 0
+
+
+class CronJobStatus(BaseModel):
+    name: str
+    namespace: str
+    active: int = 0
+    last_schedule: Optional[str] = None
+
+
+class ClusterSnapshot(BaseModel):
+    namespace: str
+    jobs: List[JobStatus] = Field(default_factory=list)
+    pods: List[PodInfo] = Field(default_factory=list)
+    deployments: List[DeploymentStatus] = Field(default_factory=list)
+    cronjobs: List[CronJobStatus] = Field(default_factory=list)

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/app.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+
+import os
+import re
+import time
+from typing import Tuple
+
+import gradio as gr
+
+from agentctl.config import settings
+from agentctl.k8s_client import K8sClient
+from agentctl.agent import K8sAgent
+
+
+# ---------------------------------------------------------------------
+# Core objects
+# ---------------------------------------------------------------------
+
+agent = K8sAgent()
+
+
+def _get_client() -> K8sClient:
+    """Create a Kubernetes HTTP client using env-based config."""
+    return K8sClient()
+
+
+# ---------------------------------------------------------------------
+# YAML generation + apply
+# ---------------------------------------------------------------------
+
+
+def generate_yaml_from_prompt(prompt: str, namespace: str, kind: str) -> str:
+    """Convert natural language + kind selection into YAML."""
+    if not prompt.strip():
+        return "# Enter a description, e.g. 'run a python preprocessing job'"
+
+    ns = namespace.strip() or settings.k8s_namespace
+    kind_sel = None if kind == "Auto" else kind
+
+    _, yaml_text = agent.nl_to_resource_yaml(
+        prompt,
+        namespace=ns,
+        kind=kind_sel,
+    )
+    return yaml_text
+
+
+def apply_yaml_to_cluster(yaml_text: str) -> Tuple[str, str]:
+    """Apply a YAML manifest to the cluster via K8s API."""
+    if not yaml_text.strip():
+        return "No YAML to apply.", ""
+
+    client = _get_client()
+    result = client.apply_manifest(yaml_text)
+
+    raw_str = ""
+    if result.raw_response is not None:
+        try:
+            raw_str = str(result.raw_response)
+        except Exception:
+            raw_str = "<unserialisable response>"
+
+    prefix = "✅" if result.success else "❌"
+    return f"{prefix} {result.message}", raw_str
+
+
+# ---------------------------------------------------------------------
+# Dashboard snapshot
+# ---------------------------------------------------------------------
+
+
+def get_cluster_snapshot() -> str:
+    """Return a human-readable snapshot of Jobs, Pods, Deployments, CronJobs."""
+    client = _get_client()
+    snap = client.snapshot()
+
+    lines: list[str] = [f"Namespace: {snap.namespace}", ""]
+
+    # Jobs
+    lines.append("Jobs:")
+    if not snap.jobs:
+        lines.append("  (no jobs)")
+    else:
+        for j in snap.jobs:
+            lines.append(
+                f"  - {j.name}: succeeded={j.succeeded}, "
+                f"failed={j.failed}, active={j.active}"
+            )
+
+    # Pods
+    lines.append("")
+    lines.append("Pods:")
+    if not snap.pods:
+        lines.append("  (no pods)")
+    else:
+        for p in snap.pods:
+            lines.append(f"  - {p.name}: phase={p.phase}")
+
+    # Deployments
+    lines.append("")
+    lines.append("Deployments:")
+    if not snap.deployments:
+        lines.append("  (no deployments)")
+    else:
+        for d in snap.deployments:
+            lines.append(
+                f"  - {d.name}: replicas={d.replicas}, ready={d.ready}"
+            )
+
+    # CronJobs
+    lines.append("")
+    lines.append("CronJobs:")
+    if not snap.cronjobs:
+        lines.append("  (no cronjobs)")
+    else:
+        for c in snap.cronjobs:
+            last = c.last_schedule or "never"
+            lines.append(
+                f"  - {c.name}: active={c.active}, lastScheduleTime={last}"
+            )
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------
+# Logs helpers (colorised terminal + live follow)
+# ---------------------------------------------------------------------
+
+
+def _fetch_pod_logs_raw(pod_name: str, tail_lines: int) -> str:
+    """Internal: raw log text from Kubernetes."""
+    client = _get_client()
+    return client.get_pod_logs(pod_name.strip(), tail_lines=tail_lines)
+
+
+def _colorize_logs(text: str) -> str:
+    """Convert log text into HTML with basic severity colouring."""
+    if not text:
+        return "<span style='color:#888;'>No logs</span>"
+
+    lines = text.splitlines()
+    out: list[str] = []
+
+    for line in lines:
+        if re.search(r"(error|failed|exception)", line, re.IGNORECASE):
+            colour = "#ff4b4b"  # red
+        elif re.search(r"(warn)", line, re.IGNORECASE):
+            colour = "#f7c843"  # yellow
+        elif re.search(r"(info|started|running|completed)", line, re.IGNORECASE):
+            colour = "#5ad55a"  # green
+        else:
+            colour = "#d0d0d0"  # grey
+
+        safe = line.replace("<", "&lt;").replace(">", "&gt;")
+        out.append(f"<span style='color:{colour};'>{safe}</span>")
+
+    return "<br>".join(out)
+
+
+def get_pod_logs_once(pod_name: str, tail_lines: int) -> str:
+    """One-shot logs fetch, used for the 'Get logs' button."""
+    pod_name = pod_name.strip()
+    if not pod_name:
+        return "<span style='color:#ff4b4b;'>Enter a pod name from the dashboard.</span>"
+
+    raw = _fetch_pod_logs_raw(pod_name, tail_lines)
+    return _colorize_logs(raw)
+
+
+def follow_pod_logs(pod_name: str, tail_lines: int):
+    """Live streaming logs using Gradio generator output."""
+    pod_name = pod_name.strip()
+    if not pod_name:
+        yield "<span style='color:#ff4b4b;'>Enter a pod name from the dashboard.</span>"
+        return
+
+    while True:
+        raw = _fetch_pod_logs_raw(pod_name, tail_lines)
+        html = _colorize_logs(raw)
+        yield html
+        time.sleep(2)
+
+
+# CSS for the logs "terminal"
+TERMINAL_CSS = """
+#logs_terminal {
+    background-color: #111111 !important;
+    color: #d0d0d0 !important;
+    font-family: monospace !important;
+    padding: 14px;
+    border-radius: 8px;
+    border: 1px solid #444444;
+    height: 420px;
+    overflow-y: scroll;
+    white-space: pre-wrap;
+}
+"""
+
+
+# ---------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------
+
+
+def build_app() -> gr.Blocks:
+    with gr.Blocks(
+        title="AgentCTL: LLM-Driven Kubernetes Automation",
+        css=TERMINAL_CSS,
+    ) as demo:
+        # Top environment hint (like your screenshot)
+        gr.Markdown(
+            """
+### 🔧 Environment configuration
+
+- `K8S_API_BASE_URL` → **public K8s API URL** (ngrok / Cloudflare tunnel over `kubectl proxy`)
+- `K8S_NAMESPACE` → **default namespace** (e.g. `default`)
+- `K8S_VERIFY_SSL` → **true/false** (set `false` for self-signed ngrok endpoints)
+- `AGENTCTL_USE_LLM` → **true/false** (optional; uses OpenAI if enabled in `agent.py`)
+- `OPENAI_API_KEY` → your key (if LLM mode enabled)
+
+---
+"""
+        )
+
+        # ============================================================
+        # Create Resource tab
+        # ============================================================
+        with gr.Tab("Create Resource"):
+            with gr.Row():
+                prompt = gr.Textbox(
+                    label="Describe the resource you want",
+                    placeholder=(
+                        "Examples:\n"
+                        "- run a python job to preprocess data\n"
+                        "- create an nginx deployment with 3 replicas\n"
+                        "- schedule a python cleanup job every 5 minutes\n"
+                    ),
+                    lines=5,
+                )
+
+                with gr.Column():
+                    namespace = gr.Textbox(
+                        label="Kubernetes namespace",
+                        value=settings.k8s_namespace,
+                        lines=1,
+                    )
+                    kind = gr.Dropdown(
+                        label="Resource kind",
+                        choices=["Auto", "Job", "Deployment", "CronJob"],
+                        value="Auto",
+                    )
+                    gr.Markdown(
+                        "Tip: leave **Auto** to let the agent infer Job vs Deployment vs CronJob."
+                    )
+
+            generate_btn = gr.Button("Generate YAML", variant="primary")
+            yaml_box = gr.Code(
+                label="Generated manifest (YAML)",
+                language="yaml",
+                lines=22,
+            )
+
+            apply_btn = gr.Button("Apply to cluster")
+            apply_msg = gr.Textbox(label="Status", interactive=False)
+            apply_raw = gr.Textbox(label="Raw API response (debug)")
+
+            generate_btn.click(
+                fn=generate_yaml_from_prompt,
+                inputs=[prompt, namespace, kind],
+                outputs=yaml_box,
+            )
+
+            apply_btn.click(
+                fn=apply_yaml_to_cluster,
+                inputs=[yaml_box],
+                outputs=[apply_msg, apply_raw],
+            )
+
+        # ============================================================
+        # Cluster Dashboard tab
+        # ============================================================
+        with gr.Tab("Cluster Dashboard"):
+            gr.Markdown(
+                "Snapshot of **Jobs, Pods, Deployments, CronJobs** in the target namespace."
+            )
+            snapshot_btn = gr.Button("Refresh snapshot", variant="primary")
+            snapshot_box = gr.Textbox(
+                label="Cluster overview",
+                lines=25,
+                interactive=False,
+            )
+
+            snapshot_btn.click(
+                fn=get_cluster_snapshot,
+                inputs=[],
+                outputs=[snapshot_box],
+            )
+
+        # ============================================================
+        # Pod Logs tab
+        # ============================================================
+        with gr.Tab("Pod Logs"):
+            gr.Markdown(
+                "Paste a pod name from the **Cluster Dashboard** (e.g. `agentctl-job-lnrcp`) "
+                "and fetch its logs. Use **Follow logs** for a live `kubectl logs -f` style view."
+            )
+
+            pod_name = gr.Textbox(
+                label="Pod name",
+                placeholder="e.g. preprocess-job-z48rz",
+            )
+            tail_lines = gr.Slider(
+                label="Tail lines",
+                minimum=10,
+                maximum=500,
+                step=10,
+                value=100,
+            )
+
+            with gr.Row():
+                get_logs_btn = gr.Button("Get logs once")
+                follow_logs_btn = gr.Button("Follow logs (live)", variant="primary")
+
+            logs_box = gr.HTML(label="Logs", elem_id="logs_terminal")
+
+            get_logs_btn.click(
+                fn=get_pod_logs_once,
+                inputs=[pod_name, tail_lines],
+                outputs=[logs_box],
+            )
+            
+            follow_logs_btn.click(
+                fn=follow_pod_logs,
+                inputs=[pod_name, tail_lines],
+                outputs=logs_box,
+            )
+
+    return demo
+
+
+app = build_app()
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", "7860"))
+    app.launch(server_name="0.0.0.0", server_port=port)

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+requests>=2.31.0
+PyYAML>=6.0
+pydantic>=2.7.0
+python-dotenv>=1.0.0
+openai>=1.0.0   # for LLM-based YAML generation

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/k8s/deployment-example.yaml

@@ -0,0 +1,22 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: example-nginx-deployment
+  namespace: default
+  labels:
+    app: agentctl-nginx
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: agentctl-nginx
+  template:
+    metadata:
+      labels:
+        app: agentctl-nginx
+    spec:
+      containers:
+        - name: nginx
+          image: nginx:1.27-alpine
+          ports:
+            - containerPort: 80

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/k8s/job-example.yaml

@@ -0,0 +1,21 @@
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: example-echo-job
+  namespace: default
+spec:
+  template:
+    metadata:
+      labels:
+        app: agentctl-example
+    spec:
+      restartPolicy: Never
+      containers:
+        - name: main
+          image: busybox:1.36
+          command:
+            - /bin/sh
+            - -c
+            - |
+              echo "Hello from example job";
+              sleep 10;

hf-space/hf-space/hf-space/hf-space/hf-space/requirements.txt

@@ -1,6 +1,7 @@
-gradio>=4.0.0
-requests>=2.31.0
-PyYAML>=6.0
-pydantic>=2.7.0
-python-dotenv>=1.0.0
-openai>=1.0.0   # for LLM-based YAML generation
+gradio==4.26.0
+huggingface_hub==0.19.4
+requests==2.31.0
+PyYAML==6.0
+pydantic==2.7.0
+python-dotenv==1.0.0
+openai==1.0.0

hf-space/requirements.txt

@@ -5,3 +5,5 @@ PyYAML==6.0
 pydantic==2.7.0
 python-dotenv==1.0.0
 openai==1.0.0
+fastapi
+uvicorn