kctl-api 0.2.0__py3-none-any.whl

kctl_api/commands/monitor_cmd.py

@@ -0,0 +1,243 @@
+"""Production monitoring commands for kctl-api.
+
+Real-time metrics, alerts, and uptime monitoring.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Annotated
+
+import typer
+
+from kctl_api.core.callbacks import AppContext
+
+app = typer.Typer(name="monitor", help="Production monitoring — live, metrics, uptime.", no_args_is_help=True)
+
+
+# ---------------------------------------------------------------------------
+# live
+# ---------------------------------------------------------------------------
+@app.command()
+def live(
+    ctx: typer.Context,
+    interval: Annotated[int, typer.Option("--interval", "-i", help="Refresh interval in seconds.")] = 5,
+) -> None:
+    """Live dashboard — API health, DB, Redis, container status refreshed every N seconds."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    import asyncio
+    import contextlib
+    import datetime
+    import subprocess
+
+    from kctl_api.core.utils import find_project_root
+
+    root = find_project_root()
+
+    def _get_container_status() -> list[dict]:
+        result = subprocess.run(
+            ["docker", "compose", "-f", str(root / "docker-compose.yml"), "ps", "--format", "json"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            return []
+        import json
+
+        containers = []
+        for line in result.stdout.strip().splitlines():
+            if line.strip():
+                with contextlib.suppress(json.JSONDecodeError):
+                    containers.append(json.loads(line))
+        return containers
+
+    async def _check_services() -> dict:
+        checks: dict[str, str] = {}
+
+        # API
+        try:
+            healthy, _ = actx.client.health_check()
+            checks["api-main"] = "[green]ok[/green]" if healthy else "[red]error[/red]"
+        except Exception:
+            checks["api-main"] = "[red]down[/red]"
+
+        # DB
+        try:
+            from kctl_api.core.db import dispose_engine, execute_query
+
+            db_url = actx.database_url
+            if db_url:
+                await execute_query(db_url, "SELECT 1")
+                await dispose_engine()
+                checks["postgresql"] = "[green]ok[/green]"
+            else:
+                checks["postgresql"] = "[yellow]no url[/yellow]"
+        except Exception:
+            checks["postgresql"] = "[red]error[/red]"
+
+        # Redis
+        try:
+            from kctl_api.core.redis import close_redis, get_redis
+
+            redis_url = actx.redis_url
+            if redis_url:
+                client = get_redis(redis_url)
+                await client.ping()
+                await close_redis()
+                checks["redis"] = "[green]ok[/green]"
+            else:
+                checks["redis"] = "[yellow]no url[/yellow]"
+        except Exception:
+            checks["redis"] = "[red]error[/red]"
+
+        return checks
+
+    console = out.console  # type: ignore[attr-defined]
+
+    try:
+        while True:
+            console.clear()
+            now = datetime.datetime.now(tz=datetime.UTC).strftime("%Y-%m-%d %H:%M:%S UTC")
+            out.header(f"Live Monitor — {now} (refreshing every {interval}s)")
+
+            # Service checks
+            checks = asyncio.run(_check_services())
+            out.text("")
+            out.text("  [bold]Services:[/bold]")
+            for svc, status in checks.items():
+                out.text(f"    {svc:<20} {status}")
+
+            # Container status
+            containers = _get_container_status()
+            if containers:
+                out.text("")
+                out.text("  [bold]Containers:[/bold]")
+                for c in containers:
+                    name = c.get("Name", c.get("Service", ""))
+                    state = c.get("State", c.get("Status", ""))
+                    health = c.get("Health", "")
+                    indicator = "[green]up[/green]" if "running" in state.lower() else "[red]down[/red]"
+                    health_str = f" ({health})" if health else ""
+                    out.text(f"    {name:<30} {indicator}{health_str}")
+
+            out.text("")
+            out.text("  [dim]Press Ctrl+C to stop[/dim]")
+
+            time.sleep(interval)
+    except KeyboardInterrupt:
+        out.info("Monitoring stopped.")
+
+
+# ---------------------------------------------------------------------------
+# metrics
+# ---------------------------------------------------------------------------
+@app.command()
+def metrics(ctx: typer.Context) -> None:
+    """Fetch metrics from the API (Prometheus endpoint if available)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    # Try /metrics endpoint (Prometheus format)
+    metrics_endpoints = ["/metrics", "/api/v1/metrics", "/api/v1/health"]
+
+    for endpoint in metrics_endpoints:
+        try:
+            response = actx.client.get_raw(endpoint)
+            if response.status_code == 200:
+                content_type = response.headers.get("content-type", "")
+                if "text/plain" in content_type or "prometheus" in content_type:
+                    out.header(f"Metrics: {endpoint}")
+                    # Show first 50 lines
+                    lines = response.text.splitlines()[:50]
+                    for line in lines:
+                        if not line.startswith("#"):
+                            out.text(f"  {line}")
+                    if len(response.text.splitlines()) > 50:
+                        out.text(f"  ... ({len(response.text.splitlines())} total lines)")
+                    return
+                elif "json" in content_type:
+                    import json
+
+                    data = json.loads(response.text)
+                    out.detail(
+                        title=f"Metrics: {endpoint}",
+                        sections=[("Data", [(k, str(v)) for k, v in data.items() if not isinstance(v, dict)])],
+                        data_for_json=data,
+                    )
+                    return
+        except Exception:
+            continue
+
+    out.warn("No metrics endpoint found. Consider adding prometheus-fastapi-instrumentator.")
+    out.info("  uv add prometheus-fastapi-instrumentator")
+    out.info("  Exposes: GET /metrics (Prometheus format)")
+
+
+# ---------------------------------------------------------------------------
+# uptime
+# ---------------------------------------------------------------------------
+@app.command()
+def uptime(
+    ctx: typer.Context,
+    duration: Annotated[int, typer.Option("--duration", help="Monitor uptime for N seconds (0 = single check).")] = 0,
+    interval: Annotated[int, typer.Option("--interval", "-i", help="Check interval in seconds.")] = 10,
+) -> None:
+    """Monitor API uptime — single check or continuous with SLA tracking."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    def _check() -> tuple[bool, float]:
+        start = time.monotonic()
+        try:
+            healthy, _ = actx.client.health_check()
+            elapsed_ms = (time.monotonic() - start) * 1000
+            return healthy, round(elapsed_ms, 1)
+        except Exception:
+            elapsed_ms = (time.monotonic() - start) * 1000
+            return False, round(elapsed_ms, 1)
+
+    if duration == 0:
+        # Single check
+        healthy, latency_ms = _check()
+        status = "[green]UP[/green]" if healthy else "[red]DOWN[/red]"
+        out.text(f"  Status:  {status}")
+        out.text(f"  Latency: {latency_ms}ms")
+        if actx.json_mode:
+            out.raw_json({"healthy": healthy, "latency_ms": latency_ms})
+        if not healthy:
+            raise typer.Exit(1)
+        return
+
+    # Continuous monitoring
+    out.info(f"Monitoring uptime for {duration}s (interval={interval}s) ...")
+    checks: list[tuple[bool, float]] = []
+    deadline = time.monotonic() + duration
+
+    try:
+        while time.monotonic() < deadline:
+            healthy, latency_ms = _check()
+            checks.append((healthy, latency_ms))
+            status = "[green]UP[/green]" if healthy else "[red]DOWN[/red]"
+            out.text(f"  [{len(checks)}] {status} ({latency_ms}ms)")
+            if time.monotonic() < deadline:
+                time.sleep(min(interval, deadline - time.monotonic()))
+    except KeyboardInterrupt:
+        out.info("Stopped.")
+
+    if not checks:
+        return
+
+    total = len(checks)
+    up_count = sum(1 for h, _ in checks if h)
+    sla = round(up_count / total * 100, 2)
+    avg_lat = round(sum(lat for _, lat in checks) / total, 1)
+
+    out.text("")
+    out.text(f"  Checks:     {total}")
+    out.text(f"  Uptime:     [{'green' if sla >= 99 else 'yellow'}]{sla}%[/{'green' if sla >= 99 else 'yellow'}]")
+    out.text(f"  Avg latency: {avg_lat}ms")
+
+    if actx.json_mode:
+        out.raw_json({"total": total, "up": up_count, "sla_pct": sla, "avg_latency_ms": avg_lat})

kctl_api/commands/notifications.py

@@ -0,0 +1,132 @@
+"""Notification commands for kctl-api.
+
+Send messages via Mattermost, Telegram, broadcast, and test.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_api.core.callbacks import AppContext
+from kctl_api.core.exceptions import APIError, AuthenticationError
+from kctl_api.core.exceptions import ConnectionError as KctlConnectionError
+
+app = typer.Typer(
+    name="notifications", help="Send notifications — Mattermost, Telegram, broadcast.", no_args_is_help=True
+)
+
+
+# ---------------------------------------------------------------------------
+# mattermost
+# ---------------------------------------------------------------------------
+@app.command()
+def mattermost(
+    ctx: typer.Context,
+    message: Annotated[str, typer.Argument(help="Message text to send.")],
+    channel: Annotated[str, typer.Option("--channel", "-c", help="Channel ID or name.")] = "",
+) -> None:
+    """Send a Mattermost notification via POST /api/v1/notifications/mattermost."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    payload: dict = {"message": message}
+    if channel:
+        payload["channel"] = channel
+
+    try:
+        result = actx.client.post("/api/v1/notifications/mattermost", json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success("Mattermost notification sent.")
+    if actx.json_mode:
+        out.raw_json(result)
+
+
+# ---------------------------------------------------------------------------
+# telegram
+# ---------------------------------------------------------------------------
+@app.command()
+def telegram(
+    ctx: typer.Context,
+    message: Annotated[str, typer.Argument(help="Message text to send.")],
+    chat_id: Annotated[str, typer.Option("--chat-id", "-c", help="Telegram chat ID.")] = "",
+) -> None:
+    """Send a Telegram notification via POST /api/v1/notifications/telegram."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    payload: dict = {"message": message}
+    if chat_id:
+        payload["chat_id"] = chat_id
+
+    try:
+        result = actx.client.post("/api/v1/notifications/telegram", json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success("Telegram notification sent.")
+    if actx.json_mode:
+        out.raw_json(result)
+
+
+# ---------------------------------------------------------------------------
+# broadcast
+# ---------------------------------------------------------------------------
+@app.command()
+def broadcast(
+    ctx: typer.Context,
+    message: Annotated[str, typer.Argument(help="Broadcast message.")],
+    channel_type: Annotated[str, typer.Option("--type", "-t", help="Channel type: all, mattermost, telegram.")] = "all",
+) -> None:
+    """Broadcast a message to all notification channels via POST /api/v1/notifications/broadcast."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    payload: dict = {"message": message, "channel_type": channel_type}
+
+    try:
+        result = actx.client.post("/api/v1/notifications/broadcast", json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Broadcast sent ({channel_type}).")
+    if actx.json_mode:
+        out.raw_json(result)
+
+
+# ---------------------------------------------------------------------------
+# test
+# ---------------------------------------------------------------------------
+@app.command(name="test")
+def test_notification(
+    ctx: typer.Context,
+    channel_type: Annotated[
+        str, typer.Option("--type", "-t", help="Channel type: mattermost, telegram.")
+    ] = "mattermost",
+) -> None:
+    """Send a test notification to verify configuration.
+
+    Sends a test message via the broadcast endpoint.
+    """
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    test_msg = f"[kctl-api] Test notification via {channel_type}"
+    try:
+        result = actx.client.post(
+            "/api/v1/notifications/broadcast",
+            json={"message": test_msg, "channel_type": channel_type},
+        )
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Test notification sent via {channel_type}.")
+    if actx.json_mode:
+        out.raw_json(result)

kctl_api/commands/odoo_proxy.py

@@ -0,0 +1,182 @@
+"""Odoo proxy commands for kctl-api.
+
+Admin-only JSON-RPC proxy calls to Odoo backend.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_api.core.callbacks import AppContext
+from kctl_api.core.exceptions import APIError, AuthenticationError
+from kctl_api.core.exceptions import ConnectionError as KctlConnectionError
+
+app = typer.Typer(name="odoo", help="Odoo proxy — search-read, call, create, write (admin-only).", no_args_is_help=True)
+
+_BASE = "/api/v1/odoo"
+
+
+# ---------------------------------------------------------------------------
+# search-read
+# ---------------------------------------------------------------------------
+@app.command(name="search-read")
+def search_read(
+    ctx: typer.Context,
+    model: Annotated[str, typer.Argument(help="Odoo model name (e.g. res.partner).")],
+    domain: Annotated[str, typer.Option("--domain", "-d", help="JSON domain filter.")] = "[]",
+    fields: Annotated[str, typer.Option("--fields", "-f", help="Comma-separated field names.")] = "",
+    limit: Annotated[int, typer.Option("--limit", "-n", help="Max records to return.")] = 20,
+) -> None:
+    """Search and read Odoo records via POST /api/v1/odoo/search-read (admin-only)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    import json
+
+    try:
+        domain_parsed = json.loads(domain)
+    except json.JSONDecodeError as e:
+        out.error(f"Invalid domain JSON: {e}")
+        raise typer.Exit(1) from None
+
+    payload: dict = {
+        "model": model,
+        "domain": domain_parsed,
+        "limit": limit,
+    }
+    if fields:
+        payload["fields"] = [f.strip() for f in fields.split(",")]
+
+    try:
+        result = actx.client.post(f"{_BASE}/search-read", json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    records = result if isinstance(result, list) else result.get("records", []) if isinstance(result, dict) else []
+    out.info(f"Found {len(records)} record(s).")
+
+    if actx.json_mode:
+        out.raw_json(records)
+    elif records:
+        # Auto-detect columns from first record
+        cols = list(records[0].keys()) if records else []
+        rows = [[str(r.get(c, "")) for c in cols] for r in records]
+        out.table(
+            title=f"{model} ({len(records)} records)",
+            columns=[(c, "") for c in cols],
+            rows=rows,
+            data_for_json=records,
+        )
+
+
+# ---------------------------------------------------------------------------
+# call
+# ---------------------------------------------------------------------------
+@app.command()
+def call(
+    ctx: typer.Context,
+    model: Annotated[str, typer.Argument(help="Odoo model name.")],
+    method: Annotated[str, typer.Argument(help="Method to call.")],
+    args_json: Annotated[str, typer.Option("--args", "-a", help="JSON args array.")] = "[]",
+    kwargs_json: Annotated[str, typer.Option("--kwargs", "-k", help="JSON kwargs object.")] = "{}",
+) -> None:
+    """Call an Odoo model method via POST /api/v1/odoo/call (admin-only)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    import json
+
+    try:
+        args = json.loads(args_json)
+        kwargs = json.loads(kwargs_json)
+    except json.JSONDecodeError as e:
+        out.error(f"Invalid JSON: {e}")
+        raise typer.Exit(1) from None
+
+    payload: dict = {"model": model, "method": method, "args": args, "kwargs": kwargs}
+
+    try:
+        result = actx.client.post(f"{_BASE}/call", json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Called {model}.{method}")
+    if actx.json_mode:
+        out.raw_json(result)
+    elif result:
+        out.text(str(result))
+
+
+# ---------------------------------------------------------------------------
+# create
+# ---------------------------------------------------------------------------
+@app.command()
+def create(
+    ctx: typer.Context,
+    model: Annotated[str, typer.Argument(help="Odoo model name.")],
+    values_json: Annotated[str, typer.Argument(help="JSON object with field values.")],
+) -> None:
+    """Create an Odoo record via POST /api/v1/odoo/create (admin-only)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    import json
+
+    try:
+        values = json.loads(values_json)
+    except json.JSONDecodeError as e:
+        out.error(f"Invalid JSON: {e}")
+        raise typer.Exit(1) from None
+
+    payload: dict = {"model": model, "values": values}
+
+    try:
+        result = actx.client.post(f"{_BASE}/create", json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Created {model} record.")
+    if actx.json_mode:
+        out.raw_json(result)
+    elif result:
+        out.text(str(result))
+
+
+# ---------------------------------------------------------------------------
+# write
+# ---------------------------------------------------------------------------
+@app.command()
+def write(
+    ctx: typer.Context,
+    model: Annotated[str, typer.Argument(help="Odoo model name.")],
+    record_id: Annotated[int, typer.Argument(help="Record ID to update.")],
+    values_json: Annotated[str, typer.Argument(help="JSON object with field values.")],
+) -> None:
+    """Update an Odoo record via POST /api/v1/odoo/write (admin-only)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    import json
+
+    try:
+        values = json.loads(values_json)
+    except json.JSONDecodeError as e:
+        out.error(f"Invalid JSON: {e}")
+        raise typer.Exit(1) from None
+
+    payload: dict = {"model": model, "ids": [record_id], "values": values}
+
+    try:
+        result = actx.client.post(f"{_BASE}/write", json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Updated {model} record {record_id}.")
+    if actx.json_mode:
+        out.raw_json(result)