Sync from GitHub on master (Wed Nov 19 11:34:36 UTC 2025)

README.md

@@ -1,3 +1,15 @@
+---
+title: AgentCTL – Kubernetes Agent UI
+emoji: 🧠
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: "4.42.0"
+app_file: app.py
+pinned: false
+---
+
+
 # AgentCTL — LLM-Driven Kubernetes Automation  
 ### Natural Language → Kubernetes Jobs, Deployments & CronJobs  
 Built for real clusters via Minikube + kubectl proxy + ngrok or Cloudflare Tunnel.
@@ -204,7 +216,7 @@ spec:
 ## ❤️ Credits
 
 Built by **Murali Chandran (codeninja3d)**  
-AI Agents • Kubernetes • MLOps • VFX Pipelines
+AI Agents • Kubernetes • MLOps
 
 ---
 

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/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/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/.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/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/agentctl/__init__.py

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

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/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/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/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/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/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/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/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;