toolgate-io 0.3.0__py3-none-any.whl

toolgate/__init__.py

@@ -0,0 +1,3 @@
+"""Toolgate: capability control plane for embedded AI agents."""
+
+__version__ = "0.3.0"

toolgate/cli/__init__.py

@@ -0,0 +1 @@
+"""Toolgate operator CLI — a pure client of the control-plane API."""

toolgate/cli/client.py

@@ -0,0 +1,49 @@
+from typing import Any
+
+import httpx
+import typer
+from rich.console import Console
+
+from .config import Profile
+
+err_console = Console(stderr=True)
+
+
+class AdminClient:
+    """Thin, honest wrapper over the control-plane API. Any non-2xx response is
+    rendered as the server's error envelope and exits non-zero."""
+
+    def __init__(self, profile: Profile) -> None:
+        self.url = profile.url
+        self._http = httpx.Client(
+            base_url=profile.url,
+            headers={"x-toolgate-admin-key": profile.admin_key},
+            timeout=15.0,
+        )
+
+    def get(self, path: str, **params: Any) -> Any:
+        return self._handle(
+            self._http.get(path, params={k: v for k, v in params.items() if v is not None})
+        )
+
+    def post(self, path: str, body: dict[str, Any] | None = None) -> Any:
+        return self._handle(self._http.post(path, json=body or {}))
+
+    def public(self, path: str) -> Any:
+        # Unauthenticated endpoints (/healthz, /v1/keys).
+        return self._handle(httpx.get(f"{self.url}{path}", timeout=15.0))
+
+    def _handle(self, res: httpx.Response) -> Any:
+        try:
+            body = res.json()
+        except ValueError:
+            body = {"error": {"code": "TG_INTERNAL", "message": res.text[:200]}}
+        if res.status_code >= 400:
+            err = body.get("error", {})
+            err_console.print(
+                f"[bold red]{err.get('code', res.status_code)}[/] {err.get('message', '')}"
+            )
+            if err.get("details"):
+                err_console.print(f"[dim]{err['details']}[/]")
+            raise typer.Exit(1)
+        return body

toolgate/cli/config.py

@@ -0,0 +1,48 @@
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def config_path() -> Path:
+    return Path(os.environ.get("TOOLGATE_CONFIG", "~/.toolgate/config.json")).expanduser()
+
+
+@dataclass(frozen=True)
+class Profile:
+    url: str
+    admin_key: str
+
+
+def load_profiles() -> dict[str, dict[str, str]]:
+    path = config_path()
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text())
+
+
+def save_profile(name: str, url: str, admin_key: str) -> Path:
+    path = config_path()
+    profiles = load_profiles()
+    profiles[name] = {"url": url.rstrip("/"), "admin_key": admin_key}
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(profiles, indent=2) + "\n")
+    path.chmod(0o600)
+    return path
+
+
+def resolve(profile: str | None) -> Profile:
+    """Environment wins (CI/scripting); otherwise the named or default profile."""
+    env_url = os.environ.get("TOOLGATE_URL")
+    env_key = os.environ.get("TOOLGATE_ADMIN_KEY")
+    if env_url and env_key:
+        return Profile(url=env_url.rstrip("/"), admin_key=env_key)
+
+    profiles = load_profiles()
+    name = profile or "default"
+    if name not in profiles:
+        raise LookupError(
+            f"no profile '{name}' — run `toolgate init` or set TOOLGATE_URL and TOOLGATE_ADMIN_KEY"
+        )
+    entry = profiles[name]
+    return Profile(url=entry["url"], admin_key=entry["admin_key"])