kaos-cli 0.0.1__py3-none-any.whl

kaos_cli/__init__.py

@@ -0,0 +1,3 @@
+"""KAOS CLI - CLI for K8s Agent Orchestration System."""
+
+__version__ = "0.1.0"

kaos_cli/install.py

@@ -0,0 +1,121 @@
+"""KAOS install/uninstall commands for the Kubernetes operator."""
+
+import shutil
+import subprocess
+import sys
+
+import typer
+
+# Helm chart repository URL (hosted on GitHub Pages)
+HELM_REPO_URL = "https://axsaucedo.github.io/kaos/charts"
+HELM_REPO_NAME = "kaos"
+HELM_CHART_NAME = "kaos-operator"
+DEFAULT_NAMESPACE = "kaos-system"
+DEFAULT_RELEASE_NAME = "kaos"
+
+
+def check_helm_installed() -> bool:
+    """Check if helm is installed and available."""
+    return shutil.which("helm") is not None
+
+
+def run_helm_command(args: list[str], check: bool = True) -> subprocess.CompletedProcess:
+    """Run a helm command and return the result."""
+    cmd = ["helm"] + args
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=check,
+        )
+        return result
+    except subprocess.CalledProcessError as e:
+        typer.echo(f"Error running helm: {e.stderr}", err=True)
+        raise
+
+
+def install_command(
+    namespace: str,
+    release_name: str,
+    version: str | None,
+    set_values: list[str],
+    wait: bool,
+) -> None:
+    """Install the KAOS operator using Helm."""
+    if not check_helm_installed():
+        typer.echo("Error: helm is not installed. Please install helm first.", err=True)
+        typer.echo("See: https://helm.sh/docs/intro/install/", err=True)
+        sys.exit(1)
+
+    typer.echo(f"Installing KAOS operator to namespace '{namespace}'...")
+
+    # Add the Helm repository
+    typer.echo(f"Adding Helm repository '{HELM_REPO_NAME}'...")
+    result = run_helm_command(
+        ["repo", "add", HELM_REPO_NAME, HELM_REPO_URL, "--force-update"],
+        check=False,
+    )
+    if result.returncode != 0 and "already exists" not in result.stderr:
+        typer.echo(f"Warning: {result.stderr}", err=True)
+
+    # Update repositories
+    typer.echo("Updating Helm repositories...")
+    run_helm_command(["repo", "update"], check=False)
+
+    # Build helm install command
+    helm_args = [
+        "upgrade",
+        "--install",
+        release_name,
+        f"{HELM_REPO_NAME}/{HELM_CHART_NAME}",
+        "--namespace",
+        namespace,
+        "--create-namespace",
+    ]
+
+    if version:
+        helm_args.extend(["--version", version])
+
+    if wait:
+        helm_args.append("--wait")
+
+    for value in set_values:
+        helm_args.extend(["--set", value])
+
+    typer.echo(f"Installing chart {HELM_CHART_NAME}...")
+    result = run_helm_command(helm_args)
+
+    if result.returncode == 0:
+        typer.echo("")
+        typer.echo("✅ KAOS operator installed successfully!")
+        typer.echo("")
+        typer.echo("Next steps:")
+        typer.echo(f"  1. Check the operator status: kubectl get pods -n {namespace}")
+        typer.echo("  2. Create your first agent: kubectl apply -f your-agent.yaml")
+        typer.echo("  3. Open the UI: kaos ui")
+    else:
+        typer.echo(f"Error: {result.stderr}", err=True)
+        sys.exit(1)
+
+
+def uninstall_command(namespace: str, release_name: str) -> None:
+    """Uninstall the KAOS operator using Helm."""
+    if not check_helm_installed():
+        typer.echo("Error: helm is not installed.", err=True)
+        sys.exit(1)
+
+    typer.echo(f"Uninstalling KAOS operator from namespace '{namespace}'...")
+
+    result = run_helm_command(
+        ["uninstall", release_name, "--namespace", namespace],
+        check=False,
+    )
+
+    if result.returncode == 0:
+        typer.echo("✅ KAOS operator uninstalled successfully!")
+    elif "not found" in result.stderr.lower():
+        typer.echo(f"Release '{release_name}' not found in namespace '{namespace}'.")
+    else:
+        typer.echo(f"Error: {result.stderr}", err=True)
+        sys.exit(1)

kaos_cli/main.py

@@ -0,0 +1,117 @@
+"""KAOS CLI main entry point."""
+
+from typing import List
+
+import typer
+
+from kaos_cli.install import (
+    DEFAULT_NAMESPACE,
+    DEFAULT_RELEASE_NAME,
+    install_command,
+    uninstall_command,
+)
+from kaos_cli.ui import ui_command
+
+# Disable shell completion message
+app = typer.Typer(
+    add_completion=False,
+    help="KAOS - K8s Agent Orchestration System CLI",
+    no_args_is_help=True,
+)
+
+
+@app.command(name="ui")
+def ui(
+    k8s_url: str = typer.Option(
+        None,
+        "--k8s-url",
+        help="Kubernetes API server URL. If not provided, uses kubeconfig.",
+    ),
+    expose_port: int = typer.Option(
+        8010,
+        "--expose-port",
+        help="Port to expose the CORS proxy on.",
+    ),
+    namespace: str = typer.Option(
+        "default",
+        "--namespace",
+        "-n",
+        help="Initial namespace to display in the UI.",
+    ),
+    no_browser: bool = typer.Option(
+        False,
+        "--no-browser",
+        help="Don't automatically open the browser.",
+    ),
+) -> None:
+    """Start a CORS-enabled proxy and open the KAOS UI."""
+    ui_command(k8s_url=k8s_url, expose_port=expose_port, namespace=namespace, no_browser=no_browser)
+
+
+@app.command(name="install")
+def install(
+    namespace: str = typer.Option(
+        DEFAULT_NAMESPACE,
+        "--namespace",
+        "-n",
+        help="Kubernetes namespace to install into.",
+    ),
+    release_name: str = typer.Option(
+        DEFAULT_RELEASE_NAME,
+        "--release-name",
+        help="Helm release name.",
+    ),
+    version: str = typer.Option(
+        None,
+        "--version",
+        help="Chart version to install. Defaults to latest.",
+    ),
+    set_values: List[str] = typer.Option(
+        [],
+        "--set",
+        help="Set Helm values (can be used multiple times).",
+    ),
+    wait: bool = typer.Option(
+        False,
+        "--wait",
+        help="Wait for pods to be ready before returning.",
+    ),
+) -> None:
+    """Install the KAOS operator using Helm."""
+    install_command(
+        namespace=namespace,
+        release_name=release_name,
+        version=version,
+        set_values=list(set_values),
+        wait=wait,
+    )
+
+
+@app.command(name="uninstall")
+def uninstall(
+    namespace: str = typer.Option(
+        DEFAULT_NAMESPACE,
+        "--namespace",
+        "-n",
+        help="Kubernetes namespace to uninstall from.",
+    ),
+    release_name: str = typer.Option(
+        DEFAULT_RELEASE_NAME,
+        "--release-name",
+        help="Helm release name.",
+    ),
+) -> None:
+    """Uninstall the KAOS operator."""
+    uninstall_command(namespace=namespace, release_name=release_name)
+
+
+@app.command(name="version")
+def version() -> None:
+    """Show the KAOS CLI version."""
+    from kaos_cli import __version__
+
+    typer.echo(f"kaos-cli {__version__}")
+
+
+if __name__ == "__main__":
+    app()

kaos_cli/proxy.py

@@ -0,0 +1,105 @@
+"""CORS-enabled Kubernetes API proxy."""
+
+import ssl
+
+import httpx
+from kubernetes import client, config
+from starlette.applications import Starlette
+from starlette.middleware.cors import CORSMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.routing import Route
+
+
+def create_proxy_app(k8s_url: str | None = None) -> Starlette:
+    """Create a Starlette app that proxies requests to the K8s API with CORS."""
+    # Load kubernetes config
+    try:
+        config.load_incluster_config()
+    except config.ConfigException:
+        config.load_kube_config()
+
+    configuration = client.Configuration.get_default_copy()
+
+    # Use provided URL or from kubeconfig
+    api_url = k8s_url or configuration.host
+
+    # Get auth info from configuration
+    auth_headers: dict[str, str] = {}
+    if configuration.api_key and "authorization" in configuration.api_key:
+        auth_headers["Authorization"] = configuration.api_key["authorization"]
+    elif configuration.api_key_prefix and configuration.api_key:
+        for key, value in configuration.api_key.items():
+            prefix = configuration.api_key_prefix.get(key, "")
+            auth_headers["Authorization"] = f"{prefix} {value}".strip()
+            break
+
+    # SSL/TLS configuration - handle client certificates
+    ssl_context: ssl.SSLContext | bool = False
+    if configuration.cert_file and configuration.key_file:
+        ssl_context = ssl.create_default_context()
+        ssl_context.load_cert_chain(
+            certfile=configuration.cert_file,
+            keyfile=configuration.key_file,
+        )
+        if configuration.ssl_ca_cert:
+            ssl_context.load_verify_locations(cafile=configuration.ssl_ca_cert)
+        else:
+            ssl_context.check_hostname = False
+            ssl_context.verify_mode = ssl.CERT_NONE
+    elif configuration.ssl_ca_cert:
+        ssl_context = ssl.create_default_context(cafile=configuration.ssl_ca_cert)
+
+    async def proxy_request(request: Request) -> Response:
+        """Proxy incoming requests to the Kubernetes API server."""
+        path = request.url.path
+        query = str(request.url.query) if request.url.query else ""
+        target_url = f"{api_url}{path}"
+        if query:
+            target_url = f"{target_url}?{query}"
+
+        # Start with auth headers
+        headers = dict(auth_headers)
+
+        # Copy relevant headers from request
+        for key in ["content-type", "accept", "mcp-session-id"]:
+            if key in request.headers:
+                headers[key] = request.headers[key]
+
+        # Get request body
+        body = await request.body()
+
+        async with httpx.AsyncClient(verify=ssl_context, timeout=120.0) as http_client:
+            response = await http_client.request(
+                method=request.method,
+                url=target_url,
+                headers=headers,
+                content=body if body else None,
+            )
+
+            # Build response headers
+            response_headers = dict(response.headers)
+
+            return Response(
+                content=response.content,
+                status_code=response.status_code,
+                headers=response_headers,
+                media_type=response.headers.get("content-type"),
+            )
+
+    routes = [
+        Route("/{path:path}", proxy_request, methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"]),
+    ]
+
+    app = Starlette(routes=routes)
+
+    # Add CORS middleware with mcp-session-id exposed
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+        expose_headers=["mcp-session-id"],
+    )
+
+    return app

kaos_cli/ui.py

@@ -0,0 +1,57 @@
+"""KAOS UI command - starts a CORS-enabled K8s API proxy."""
+
+import signal
+import sys
+import threading
+import time
+import webbrowser
+from urllib.parse import urlencode
+
+import typer
+import uvicorn
+
+# KAOS UI hosted on GitHub Pages
+KAOS_UI_URL = "https://axsaucedo.github.io/kaos-ui/"
+
+
+def ui_command(k8s_url: str | None, expose_port: int, namespace: str, no_browser: bool) -> None:
+    """Start a CORS-enabled proxy to the Kubernetes API server."""
+    from kaos_cli.proxy import create_proxy_app
+
+    app = create_proxy_app(k8s_url=k8s_url)
+
+    typer.echo(f"Starting KAOS UI proxy on http://localhost:{expose_port}")
+    
+    # Build UI URL with query parameters
+    query_params = {}
+    # Only add kubernetesUrl if not using default port
+    if expose_port != 8010:
+        query_params["kubernetesUrl"] = f"http://localhost:{expose_port}"
+    # Only add namespace if not using default
+    if namespace and namespace != "default":
+        query_params["namespace"] = namespace
+    
+    ui_url = KAOS_UI_URL
+    if query_params:
+        ui_url = f"{KAOS_UI_URL}?{urlencode(query_params)}"
+    
+    typer.echo(f"KAOS UI: {ui_url}")
+    typer.echo("Press Ctrl+C to stop")
+
+    def handle_signal(signum: int, frame: object) -> None:
+        typer.echo("\nShutting down...")
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, handle_signal)
+    signal.signal(signal.SIGTERM, handle_signal)
+
+    # Open browser after a short delay to allow server to start
+    if not no_browser:
+        def open_browser() -> None:
+            time.sleep(1.5)
+            webbrowser.open(ui_url)
+
+        browser_thread = threading.Thread(target=open_browser, daemon=True)
+        browser_thread.start()
+
+    uvicorn.run(app, host="0.0.0.0", port=expose_port, log_level="info")

kaos_cli-0.0.1.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: kaos-cli
+Version: 0.0.1
+Summary: CLI for KAOS (K8s Agent Orchestration System)
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: starlette>=0.37.0
+Requires-Dist: kubernetes>=29.0.0
+
+# KAOS CLI
+
+Command-line interface for KAOS (K8s Agent Orchestration System).
+
+## Installation
+
+```bash
+cd kaos-cli
+uv sync
+source .venv/bin/activate
+```
+
+## Usage
+
+### Start UI Proxy
+
+Start a CORS-enabled proxy to the Kubernetes API server:
+
+```bash
+kaos ui
+```
+
+This starts a local proxy on port 8010 that:
+- Proxies requests to the Kubernetes API using your kubeconfig credentials
+- Adds CORS headers to enable browser-based access
+- Exposes the `mcp-session-id` header for MCP protocol support
+
+Options:
+- `--k8s-url`: Override the Kubernetes API URL (default: from kubeconfig)
+- `--expose-port`: Port to expose the proxy on (default: 8010)
+- `--namespace`, `-n`: Initial namespace to display in the UI (default: "default")
+- `--no-browser`: Don't automatically open the browser
+
+Example:
+```bash
+# Use default settings
+kaos ui
+
+# Custom port
+kaos ui --expose-port 9000
+
+# Start with a specific namespace
+kaos ui --namespace kaos-system
+
+# Custom K8s URL
+kaos ui --k8s-url https://my-cluster:6443
+```
+
+### Version
+
+```bash
+kaos version
+```
+
+## Development
+
+```bash
+# Run tests
+pytest
+
+# Run directly
+python -m kaos_cli.main ui
+```

kaos_cli-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+kaos_cli/__init__.py,sha256=1Yxq51Ckr8SnrwtSuCn9JKnQIJ0CDEh5CX2-zZh3CHQ,80
+kaos_cli/install.py,sha256=B3n0moEM3RTV62u9p7GVUQYWgz8N2tkbkfJ6LlVMdW0,3693
+kaos_cli/main.py,sha256=UpirI5tN_jgSYSfeRTQZNKzuAqv0A45LqRMLoepAyJ4,2833
+kaos_cli/proxy.py,sha256=wLfxxPGxvv9yHX2mQ-FoLiQIXVJSvb2WwgEsfRVr1Qo,3702
+kaos_cli/ui.py,sha256=PRXjdV58V3XM0Cyb2OuRJKXJxPigsCDvyiB5J5XAyGU,1764
+kaos_cli-0.0.1.dist-info/METADATA,sha256=8IAz5Fk4j93JKiBA-m5WD1AA2m0sRKYad5CQdzilNRc,1462
+kaos_cli-0.0.1.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+kaos_cli-0.0.1.dist-info/entry_points.txt,sha256=UhLExeu2qKkwddNEEm0o5TKtVqOkcIEcrWqyyt_UVl4,43
+kaos_cli-0.0.1.dist-info/top_level.txt,sha256=33XlAB5b22FEtftzn0QyWXr6f8TNyh-XBIoRcQp0NRA,9
+kaos_cli-0.0.1.dist-info/RECORD,,

kaos_cli-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kaos_cli-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kaos = kaos_cli.main:app

kaos_cli-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+kaos_cli