argus-cli 0.1.0__py3-none-any.whl

argus_cli/__init__.py

@@ -0,0 +1,10 @@
+"""Argus CLI — Interactive command-line interface for Argus MCP."""
+
+__all__ = ["__version__"]
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("argus-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"

argus_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m argus_cli`` invocation."""
+
+from argus_cli.main import app
+
+if __name__ == "__main__":
+    app()

argus_cli/_console.py

@@ -0,0 +1,47 @@
+"""Console singleton — shared by theme.py and output.py to avoid circular imports.
+
+The module-global singleton pattern is intentional: Rich Console configuration
+(theme, no_color) must be consistent across all output paths.  ``reset_console()``
+exists to support tests that need to reconfigure the console between runs.
+"""
+
+from __future__ import annotations
+
+__all__ = ["get_console", "reset_console"]
+
+from rich.console import Console
+
+_console: Console | None = None
+
+
+def get_console(no_color: bool | None = None) -> Console:
+    """Get or create the Rich console singleton.
+
+    Args:
+        no_color: Override color setting. When ``None``, reads from
+                  the active CLI config.
+    """
+    global _console
+    if _console is None:
+        from argus_cli.theme import ARGUS_THEME, _ensure_loaded
+
+        _ensure_loaded()
+        if no_color is None:
+            from argus_cli.config import get_config
+
+            try:
+                no_color = get_config().no_color
+            except RuntimeError:
+                no_color = False
+        _console = Console(
+            theme=ARGUS_THEME,
+            no_color=no_color,
+            stderr=False,
+        )
+    return _console
+
+
+def reset_console() -> None:
+    """Reset console singleton so the next call picks up a new theme."""
+    global _console
+    _console = None

argus_cli/client.py

@@ -0,0 +1,446 @@
+"""HTTP API client for the Argus MCP Management API.
+
+Thin adapter around :mod:`argus_mcp.api.client` that provides:
+
+- **Sync** (``ArgusClient``) and **async** (``AsyncArgusClient``) wrappers
+  that return raw ``dict`` results for CLI output rendering.
+- Retry with exponential back-off for transient transport errors.
+- SSE streaming via ``httpx-sse``.
+- ``CliConfig``-based initialisation so callers don't construct URLs manually.
+
+The underlying HTTP contract (schemas, error model, endpoint paths) is shared
+with the TUI client via ``argus_mcp.api``.
+"""
+
+from __future__ import annotations
+
+__all__ = ["ArgusClient", "ArgusClientError", "AsyncArgusClient"]
+
+import json
+import sys
+import time
+from collections.abc import AsyncGenerator
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+import httpx
+from argus_mcp.api.client import ApiClientError
+
+from argus_cli.config import CliConfig
+
+# ── Timeout configuration ──────────────────────────────────────────────
+
+DEFAULT_TIMEOUT = httpx.Timeout(connect=5.0, read=30.0, write=10.0, pool=5.0)
+SSE_TIMEOUT = httpx.Timeout(connect=5.0, read=None, write=10.0, pool=5.0)
+
+# ── Retry configuration ────────────────────────────────────────────────
+
+MAX_RETRIES = 3
+RETRY_BACKOFF_BASE = 0.5  # seconds; doubles each attempt
+
+
+class ArgusClientError(ApiClientError):
+    """CLI-specific API error with structured status_code / error / message."""
+
+    def __init__(self, status_code: int, error: str, message: str) -> None:
+        self.status_code = status_code
+        self.error = error
+        self.message = message
+        super().__init__(f"[{status_code}] {error}: {message}", status_code=status_code or None)
+
+
+def _build_headers(config: CliConfig) -> dict[str, str]:
+    """Build request headers including optional auth token."""
+    headers: dict[str, str] = {"Accept": "application/json"}
+    if config.token:
+        headers["Authorization"] = f"Bearer {config.token}"
+    return headers
+
+
+def _build_group_params(group: str | None) -> dict[str, str]:
+    """Build query params for the /groups endpoint."""
+    return {"group": group} if group else {}
+
+
+def _build_capabilities_params(
+    *,
+    type_filter: str | None = None,
+    backend: str | None = None,
+    search: str | None = None,
+) -> dict[str, str]:
+    """Build query params for the /capabilities endpoint."""
+    params: dict[str, str] = {}
+    if type_filter:
+        params["type"] = type_filter
+    if backend:
+        params["backend"] = backend
+    if search:
+        params["search"] = search
+    return params
+
+
+def _build_events_params(
+    *,
+    limit: int = 100,
+    since: str | None = None,
+    severity: str | None = None,
+) -> dict[str, str]:
+    """Build query params for the /events endpoint."""
+    params: dict[str, str] = {"limit": str(limit)}
+    if since:
+        params["since"] = since
+    if severity:
+        params["severity"] = severity
+    return params
+
+
+def _handle_response(response: httpx.Response) -> dict[str, Any]:
+    """Parse response JSON and raise on error status codes."""
+    if response.status_code >= 400:
+        try:
+            body = response.json()
+            raise ArgusClientError(
+                status_code=response.status_code,
+                error=body.get("error", "unknown_error"),
+                message=body.get("message", response.text),
+            )
+        except (json.JSONDecodeError, KeyError) as exc:
+            raise ArgusClientError(
+                status_code=response.status_code,
+                error="http_error",
+                message=response.text,
+            ) from exc
+    try:
+        result: dict[str, Any] = response.json()
+        return result
+    except json.JSONDecodeError as exc:
+        raise ArgusClientError(
+            status_code=response.status_code,
+            error="parse_error",
+            message="Response is not valid JSON",
+        ) from exc
+
+
+# ── Sync client (one-shot commands) ────────────────────────────────────
+
+
+class ArgusClient:
+    """Synchronous httpx client for one-shot CLI commands."""
+
+    def __init__(self, config: CliConfig) -> None:
+        """Initialise the client with resolved CLI configuration.
+
+        Args:
+            config: Resolved CLI configuration containing the server URL,
+                    auth token, and timeout settings.
+        """
+        self._config = config
+        self._client = httpx.Client(
+            base_url=config.base_url,
+            headers=_build_headers(config),
+            timeout=DEFAULT_TIMEOUT,
+        )
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> dict[str, Any]:
+        """Send an HTTP request with transport error handling and retry."""
+        last_exc: ArgusClientError | None = None
+        for attempt in range(MAX_RETRIES):
+            try:
+                response = getattr(self._client, method)(path, **kwargs)
+                return _handle_response(response)
+            except httpx.ConnectError as exc:
+                last_exc = ArgusClientError(
+                    0,
+                    "connection_error",
+                    f"Cannot connect to {self._config.server_url}",
+                )
+                last_exc.__cause__ = exc
+            except httpx.TimeoutException as exc:
+                last_exc = ArgusClientError(
+                    0,
+                    "timeout_error",
+                    "Request timed out",
+                )
+                last_exc.__cause__ = exc
+            except httpx.TransportError as exc:
+                last_exc = ArgusClientError(
+                    0,
+                    "transport_error",
+                    f"Network error: {exc}",
+                )
+                last_exc.__cause__ = exc
+            if attempt < MAX_RETRIES - 1:
+                time.sleep(RETRY_BACKOFF_BASE * (2**attempt))
+        raise last_exc  # type: ignore[misc]
+
+    # ── GET endpoints ──────────────────────────────────────────────────
+
+    def health(self) -> dict[str, Any]:
+        return self._request("get", "/health")
+
+    def status(self) -> dict[str, Any]:
+        return self._request("get", "/status")
+
+    def backends(self) -> dict[str, Any]:
+        return self._request("get", "/backends")
+
+    def groups(self, group: str | None = None) -> dict[str, Any]:
+        return self._request("get", "/groups", params=_build_group_params(group))
+
+    def capabilities(
+        self,
+        *,
+        type_filter: str | None = None,
+        backend: str | None = None,
+        search: str | None = None,
+    ) -> dict[str, Any]:
+        params = _build_capabilities_params(
+            type_filter=type_filter,
+            backend=backend,
+            search=search,
+        )
+        return self._request("get", "/capabilities", params=params)
+
+    def sessions(self) -> dict[str, Any]:
+        return self._request("get", "/sessions")
+
+    def events(
+        self,
+        *,
+        limit: int = 100,
+        since: str | None = None,
+        severity: str | None = None,
+    ) -> dict[str, Any]:
+        params = _build_events_params(limit=limit, since=since, severity=severity)
+        return self._request("get", "/events", params=params)
+
+    # ── POST endpoints ─────────────────────────────────────────────────
+
+    def reload(self) -> dict[str, Any]:
+        return self._request("post", "/reload")
+
+    def reconnect(self, name: str) -> dict[str, Any]:
+        return self._request("post", f"/reconnect/{name}")
+
+    def shutdown(self, timeout_seconds: int = 30) -> dict[str, Any]:
+        return self._request("post", "/shutdown", json={"timeout_seconds": timeout_seconds})
+
+    # ── Registry endpoints ─────────────────────────────────────────────
+
+    def registry_search(
+        self,
+        query: str,
+        *,
+        limit: int = 20,
+        registry: str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"q": query, "limit": limit}
+        if registry:
+            params["registry"] = registry
+        return self._request("get", "/registry/search", params=params)
+
+    # ── Skills endpoints ───────────────────────────────────────────────
+
+    def skills_list(self) -> dict[str, Any]:
+        return self._request("get", "/skills")
+
+    def skills_enable(self, name: str) -> dict[str, Any]:
+        return self._request("post", f"/skills/{name}/enable")
+
+    def skills_disable(self, name: str) -> dict[str, Any]:
+        return self._request("post", f"/skills/{name}/disable")
+
+    def call_tool(self, name: str, arguments: dict[str, Any] | None = None) -> dict[str, Any]:
+        payload = {"tool": name, "arguments": arguments or {}}
+        return self._request("post", "/tools/call", json=payload)
+
+    def read_resource(self, uri: str) -> dict[str, Any]:
+        return self._request("post", "/resources/read", json={"uri": uri})
+
+
+# ── Async client (REPL mode) ──────────────────────────────────────────
+
+
+class AsyncArgusClient:
+    """Async httpx client for REPL mode."""
+
+    def __init__(self, config: CliConfig) -> None:
+        """Initialise the async client with resolved CLI configuration.
+
+        Args:
+            config: Resolved CLI configuration containing the server URL,
+                    auth token, and timeout settings.
+        """
+        self._config = config
+        self._client = httpx.AsyncClient(
+            base_url=config.base_url,
+            headers=_build_headers(config),
+            timeout=DEFAULT_TIMEOUT,
+        )
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        await self.close()
+
+    async def _request(self, method: str, path: str, **kwargs: Any) -> dict[str, Any]:
+        """Send an async HTTP request with transport error handling and retry."""
+        import asyncio
+
+        last_exc: ArgusClientError | None = None
+        for attempt in range(MAX_RETRIES):
+            try:
+                response = await getattr(self._client, method)(path, **kwargs)
+                return _handle_response(response)
+            except httpx.ConnectError as exc:
+                last_exc = ArgusClientError(
+                    0,
+                    "connection_error",
+                    f"Cannot connect to {self._config.server_url}",
+                )
+                last_exc.__cause__ = exc
+            except httpx.TimeoutException as exc:
+                last_exc = ArgusClientError(
+                    0,
+                    "timeout_error",
+                    "Request timed out",
+                )
+                last_exc.__cause__ = exc
+            except httpx.TransportError as exc:
+                last_exc = ArgusClientError(
+                    0,
+                    "transport_error",
+                    f"Network error: {exc}",
+                )
+                last_exc.__cause__ = exc
+            if attempt < MAX_RETRIES - 1:
+                await asyncio.sleep(RETRY_BACKOFF_BASE * (2**attempt))
+        raise last_exc  # type: ignore[misc]
+
+    # ── GET endpoints ──────────────────────────────────────────────────
+
+    async def health(self) -> dict[str, Any]:
+        return await self._request("get", "/health")
+
+    async def status(self) -> dict[str, Any]:
+        return await self._request("get", "/status")
+
+    async def backends(self) -> dict[str, Any]:
+        return await self._request("get", "/backends")
+
+    async def groups(self, group: str | None = None) -> dict[str, Any]:
+        return await self._request("get", "/groups", params=_build_group_params(group))
+
+    async def capabilities(
+        self,
+        *,
+        type_filter: str | None = None,
+        backend: str | None = None,
+        search: str | None = None,
+    ) -> dict[str, Any]:
+        params = _build_capabilities_params(
+            type_filter=type_filter,
+            backend=backend,
+            search=search,
+        )
+        return await self._request("get", "/capabilities", params=params)
+
+    async def sessions(self) -> dict[str, Any]:
+        return await self._request("get", "/sessions")
+
+    async def events(
+        self,
+        *,
+        limit: int = 100,
+        since: str | None = None,
+        severity: str | None = None,
+    ) -> dict[str, Any]:
+        params = _build_events_params(limit=limit, since=since, severity=severity)
+        return await self._request("get", "/events", params=params)
+
+    # ── POST endpoints ─────────────────────────────────────────────────
+
+    async def reload(self) -> dict[str, Any]:
+        return await self._request("post", "/reload")
+
+    async def reconnect(self, name: str) -> dict[str, Any]:
+        return await self._request("post", f"/reconnect/{name}")
+
+    async def shutdown(self, timeout_seconds: int = 30) -> dict[str, Any]:
+        return await self._request("post", "/shutdown", json={"timeout_seconds": timeout_seconds})
+
+    # ── Registry endpoints ─────────────────────────────────────────────
+
+    async def registry_search(
+        self,
+        query: str,
+        *,
+        limit: int = 20,
+        registry: str | None = None,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"q": query, "limit": limit}
+        if registry:
+            params["registry"] = registry
+        return await self._request("get", "/registry/search", params=params)
+
+    # ── Skills endpoints ───────────────────────────────────────────────
+
+    async def skills_list(self) -> dict[str, Any]:
+        return await self._request("get", "/skills")
+
+    async def skills_enable(self, name: str) -> dict[str, Any]:
+        return await self._request("post", f"/skills/{name}/enable")
+
+    async def skills_disable(self, name: str) -> dict[str, Any]:
+        return await self._request("post", f"/skills/{name}/disable")
+
+    async def call_tool(self, name: str, arguments: dict[str, Any] | None = None) -> dict[str, Any]:
+        payload = {"tool": name, "arguments": arguments or {}}
+        return await self._request("post", "/tools/call", json=payload)
+
+    async def read_resource(self, uri: str) -> dict[str, Any]:
+        return await self._request("post", "/resources/read", json={"uri": uri})
+
+    # ── SSE streaming ──────────────────────────────────────────────────
+
+    async def events_stream(self) -> AsyncGenerator[dict[str, Any], None]:
+        """Yield SSE events from /events/stream as dicts.
+
+        Yields:
+            dict with keys: event, data, id (parsed from SSE format)
+        """
+        from httpx_sse import aconnect_sse
+
+        async with aconnect_sse(
+            self._client,
+            "GET",
+            "/events/stream",
+            timeout=SSE_TIMEOUT,
+        ) as event_source:
+            async for sse in event_source.aiter_sse():
+                try:
+                    data = json.loads(sse.data)
+                except (json.JSONDecodeError, TypeError):
+                    data = sse.data
+                yield {
+                    "event": sse.event,
+                    "data": data,
+                    "id": sse.id,
+                }

argus_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Commands package — Typer sub-apps for each command group."""

argus_cli/commands/audit.py

@@ -0,0 +1,119 @@
+"""Audit log commands — list, export."""
+
+from __future__ import annotations
+
+__all__ = ["app"]
+
+from typing import Annotated
+
+import typer
+
+from argus_cli.output import OutputOption
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command("list")
+def list_audit(
+    ctx: typer.Context,
+    limit: Annotated[int, typer.Option(help="Maximum entries to return.")] = 100,
+    type_filter: Annotated[str | None, typer.Option("--type", help="Filter by event type.")] = None,
+    search: Annotated[str | None, typer.Option(help="Search pattern.")] = None,
+    output_fmt: OutputOption = None,
+) -> None:
+    """List audit log entries."""
+    from argus_cli.client import ArgusClient, ArgusClientError
+    from argus_cli.output import OutputSpec, apply_output_option, output, print_error
+
+    apply_output_option(output_fmt)
+    config = ctx.obj
+    try:
+        with ArgusClient(config) as client:
+            data = client.events(limit=limit)
+        events = data.get("events", data)
+
+        # Client-side type filter (--type)
+        if type_filter:
+            tf = type_filter.lower()
+            events = [e for e in events if tf in str(e.get("type", "")).lower()]
+
+        # Client-side search filter
+        if search:
+            q = search.lower()
+            events = [
+                e
+                for e in events
+                if q in str(e.get("message", "")).lower()
+                or q in str(e.get("stage", "")).lower()
+                or q in str(e.get("backend", "")).lower()
+            ]
+
+        output(
+            events,
+            fmt=config.output_format,
+            spec=OutputSpec(
+                title="Audit Log",
+                columns=["timestamp", "stage", "severity", "message"],
+                key_field="severity",
+            ),
+        )
+    except ArgusClientError as e:
+        print_error(f"Failed to get audit log: {e.message}")
+        raise typer.Exit(1) from None
+
+
+@app.command()
+def export(
+    ctx: typer.Context,
+    fmt: Annotated[
+        str, typer.Option("--format", "-f", help="Export format: json or csv.")
+    ] = "json",
+    since: Annotated[str | None, typer.Option(help="Export since timestamp (ISO 8601).")] = None,
+    limit: Annotated[int, typer.Option(help="Maximum entries to export.")] = 1000,
+    output_file: Annotated[
+        str | None, typer.Option("--output", "-o", help="Output file (default: stdout).")
+    ] = None,
+) -> None:
+    """Export audit log entries as JSON or CSV."""
+    import csv
+    import io
+    import json
+    import sys
+
+    from argus_cli.client import ArgusClient, ArgusClientError
+    from argus_cli.output import print_error, print_success
+
+    config = ctx.obj
+    try:
+        with ArgusClient(config) as client:
+            data = client.events(limit=limit, since=since)
+        events = data.get("events", [])
+    except ArgusClientError as e:
+        print_error(f"Failed to export audit log: {e.message}")
+        raise typer.Exit(1) from None
+
+    if fmt == "json":
+        content = json.dumps(events, indent=2, default=str)
+    elif fmt == "csv":
+        if not events:
+            content = ""
+        else:
+            buf = io.StringIO()
+            fieldnames = ["id", "timestamp", "stage", "severity", "message", "backend"]
+            writer = csv.DictWriter(buf, fieldnames=fieldnames, extrasaction="ignore")
+            writer.writeheader()
+            for event in events:
+                writer.writerow(event)
+            content = buf.getvalue()
+    else:
+        print_error(f"Unsupported format: {fmt}. Use 'json' or 'csv'.")
+        raise typer.Exit(1) from None
+
+    if output_file:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(content)
+        print_success(f"Exported {len(events)} entries to {output_file}.")
+    else:
+        sys.stdout.write(content)
+        if not content.endswith("\n"):
+            sys.stdout.write("\n")