asp-cli 0.1.0__py3-none-any.whl

asp_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

asp_cli/api_client.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import httpx
+from rich.console import Console
+
+from . import __version__
+from .config import redact_secret
+from .errors import (
+    CliError,
+    EXIT_AUTH,
+    EXIT_NETWORK,
+    EXIT_NOT_FOUND,
+    EXIT_PERMISSION,
+    EXIT_SERVER,
+    EXIT_USAGE,
+)
+
+
+class AspClient:
+    def __init__(
+        self,
+        *,
+        api_url: str,
+        api_key: str | None = None,
+        verbose: bool = False,
+        console: Console | None = None,
+        timeout: float = 20.0,
+    ) -> None:
+        self.base_url = _normalize_base_url(api_url)
+        self.api_key = api_key
+        self.verbose = verbose
+        self.console = console or Console(stderr=True)
+        self.timeout = timeout
+
+    def health(self) -> dict[str, Any]:
+        return self.request("GET", "/api/health/", authenticated=False)
+
+    def version(self) -> dict[str, Any]:
+        return self.request("GET", "/api/agent/v1/version/")
+
+    def request(self, method: str, path: str, *, authenticated: bool = True, json: Any = None, files: Any = None) -> dict[str, Any]:
+        if authenticated and not self.api_key:
+            raise CliError("missing_api_key", "API key is required", {}, EXIT_AUTH)
+
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": f"asp-cli/{__version__}",
+        }
+        if authenticated and self.api_key:
+            headers["Authorization"] = f"Api-Key {self.api_key}"
+
+        url = f"{self.base_url}{path}"
+        started = time.perf_counter()
+        try:
+            response = httpx.request(method, url, headers=headers, json=json, files=files, timeout=self.timeout)
+        except httpx.HTTPError as exc:
+            raise CliError("network_error", f"Unable to reach ASP server: {exc}", {"url": _redact_url(url)}, EXIT_NETWORK) from exc
+
+        elapsed_ms = int((time.perf_counter() - started) * 1000)
+        if self.verbose:
+            self.console.print(f"{method} {path} -> {response.status_code} ({elapsed_ms}ms)", style="dim")
+
+        if response.status_code >= 400:
+            self._raise_http_error(response, path)
+
+        if not response.content:
+            return {}
+        try:
+            payload = response.json()
+        except ValueError as exc:
+            raise CliError("invalid_response", "Server returned non-JSON response", {"status_code": response.status_code}, EXIT_SERVER) from exc
+        if not isinstance(payload, dict):
+            raise CliError("invalid_response", "Server response must be a JSON object", {"status_code": response.status_code}, EXIT_SERVER)
+        return payload
+
+    def _raise_http_error(self, response: httpx.Response, path: str) -> None:
+        message = _response_message(response)
+        details = {"status_code": response.status_code, "path": path}
+        if response.status_code == 400:
+            raise CliError("bad_request", message, details, EXIT_USAGE)
+        if response.status_code == 401:
+            raise CliError("authentication_failed", message, details, EXIT_AUTH)
+        if response.status_code == 403:
+            raise CliError("permission_denied", message, details, EXIT_PERMISSION)
+        if response.status_code == 404:
+            raise CliError("not_found", message, details, EXIT_NOT_FOUND)
+        raise CliError("server_error", message, details, EXIT_SERVER)
+
+
+def _normalize_base_url(api_url: str) -> str:
+    base = api_url.strip().rstrip("/")
+    if base.endswith("/api"):
+        base = base[:-4]
+    if not base:
+        raise CliError("missing_api_url", "ASP API URL is required", {}, EXIT_USAGE)
+    return base
+
+
+def _response_message(response: httpx.Response) -> str:
+    try:
+        payload = response.json()
+    except ValueError:
+        return response.text.strip() or f"HTTP {response.status_code}"
+    if isinstance(payload, dict):
+        detail = payload.get("detail")
+        if isinstance(detail, str):
+            return detail
+        error = payload.get("error")
+        if isinstance(error, dict) and isinstance(error.get("message"), str):
+            return error["message"]
+    return f"HTTP {response.status_code}"
+
+
+def _redact_url(url: str) -> str:
+    return url.replace(redact_secret(url), "****") if "asp_" in url else url

asp_cli/config.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .errors import CliError, EXIT_CONFIG
+
+GLOBAL_SETTINGS_PATH = Path.home() / ".asp" / "settings.json"
+LOCAL_SETTINGS_DIR = ".asp"
+SETTINGS_FILENAME = "settings.json"
+SUPPORTED_KEYS = {"api_url", "api_key"}
+
+
+@dataclass(frozen=True)
+class ResolvedConfig:
+    api_url: str | None
+    api_key: str | None
+    sources: dict[str, str]
+    global_path: Path
+    local_path: Path | None
+
+    @property
+    def has_auth(self) -> bool:
+        return bool(self.api_url and self.api_key)
+
+
+def resolve_config(*, cwd: Path | None = None, api_url: str | None = None, api_key: str | None = None) -> ResolvedConfig:
+    cwd = (cwd or Path.cwd()).resolve()
+    global_settings = read_settings(GLOBAL_SETTINGS_PATH)
+    local_path = find_local_settings(cwd)
+    local_settings = read_settings(local_path) if local_path else {}
+    values: dict[str, Any] = {}
+    sources: dict[str, str] = {}
+
+    _merge(values, sources, global_settings, "global")
+    if local_path:
+        _merge(values, sources, local_settings, "local")
+    _merge(
+        values,
+        sources,
+        {
+            "api_url": os.environ.get("ASP_API_URL"),
+            "api_key": os.environ.get("ASP_API_KEY"),
+        },
+        "env",
+    )
+    _merge(values, sources, {"api_url": api_url, "api_key": api_key}, "flags")
+
+    return ResolvedConfig(
+        api_url=_clean(values.get("api_url")),
+        api_key=_clean(values.get("api_key")),
+        sources=sources,
+        global_path=GLOBAL_SETTINGS_PATH,
+        local_path=local_path,
+    )
+
+
+def auth_settings_path(*, local: bool, cwd: Path | None = None) -> Path:
+    if local:
+        return (cwd or Path.cwd()).resolve() / LOCAL_SETTINGS_DIR / SETTINGS_FILENAME
+    return GLOBAL_SETTINGS_PATH
+
+
+def save_auth(*, api_url: str, api_key: str, local: bool = False, cwd: Path | None = None) -> Path:
+    path = auth_settings_path(local=local, cwd=cwd)
+    settings = read_settings(path)
+    settings["api_url"] = api_url.rstrip("/")
+    settings["api_key"] = api_key
+    write_settings(path, settings)
+    return path
+
+
+def clear_auth(*, local: bool = False, cwd: Path | None = None) -> Path:
+    path = auth_settings_path(local=local, cwd=cwd)
+    settings = read_settings(path)
+    settings.pop("api_url", None)
+    settings.pop("api_key", None)
+    write_settings(path, settings)
+    return path
+
+
+def set_config_value(key: str, value: str, *, local: bool = False, cwd: Path | None = None) -> Path:
+    if key not in SUPPORTED_KEYS:
+        raise CliError("invalid_config_key", f"Unsupported config key: {key}", {"supported": sorted(SUPPORTED_KEYS)}, EXIT_CONFIG)
+    path = auth_settings_path(local=local, cwd=cwd)
+    settings = read_settings(path)
+    settings[key] = value.rstrip("/") if key == "api_url" else value
+    write_settings(path, settings)
+    return path
+
+
+def get_config_value(key: str, *, cwd: Path | None = None, api_url: str | None = None, api_key: str | None = None) -> tuple[str | None, str | None]:
+    if key not in SUPPORTED_KEYS:
+        raise CliError("invalid_config_key", f"Unsupported config key: {key}", {"supported": sorted(SUPPORTED_KEYS)}, EXIT_CONFIG)
+    config = resolve_config(cwd=cwd, api_url=api_url, api_key=api_key)
+    return getattr(config, key), config.sources.get(key)
+
+
+def read_settings(path: Path | None) -> dict[str, Any]:
+    if path is None or not path.exists():
+        return {}
+    try:
+        with path.open("r", encoding="utf-8") as handle:
+            payload = json.load(handle)
+    except json.JSONDecodeError as exc:
+        raise CliError("invalid_config", f"Invalid JSON in settings file: {path}", {"path": str(path)}, EXIT_CONFIG) from exc
+    if not isinstance(payload, dict):
+        raise CliError("invalid_config", f"Settings file must contain a JSON object: {path}", {"path": str(path)}, EXIT_CONFIG)
+    return payload
+
+
+def write_settings(path: Path, settings: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        json.dump(settings, handle, indent=2, sort_keys=True)
+        handle.write("\n")
+    _restrict_permissions(path)
+
+
+def find_local_settings(cwd: Path) -> Path | None:
+    git_root = find_git_root(cwd)
+    if git_root is None:
+        candidate = cwd / LOCAL_SETTINGS_DIR / SETTINGS_FILENAME
+        return candidate if candidate.exists() else None
+
+    current = cwd
+    while True:
+        candidate = current / LOCAL_SETTINGS_DIR / SETTINGS_FILENAME
+        if candidate.exists():
+            return candidate
+        if current == git_root:
+            return None
+        current = current.parent
+
+
+def find_git_root(cwd: Path) -> Path | None:
+    current = cwd
+    while True:
+        if (current / ".git").exists():
+            return current
+        if current == current.parent:
+            return None
+        current = current.parent
+
+
+def redact_secret(value: str | None) -> str:
+    if not value:
+        return ""
+    if len(value) <= 8:
+        return "****"
+    return f"{value[:4]}...{value[-4:]}"
+
+
+def _merge(values: dict[str, Any], sources: dict[str, str], incoming: dict[str, Any], source: str) -> None:
+    for key in SUPPORTED_KEYS:
+        value = _clean(incoming.get(key))
+        if value:
+            values[key] = value
+            sources[key] = source
+
+
+def _clean(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    return text or None
+
+
+def _restrict_permissions(path: Path) -> None:
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        return

asp_cli/errors.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+EXIT_USAGE = 2
+EXIT_CONFIG = 3
+EXIT_AUTH = 4
+EXIT_PERMISSION = 5
+EXIT_NOT_FOUND = 6
+EXIT_CONFLICT = 7
+EXIT_VERSION = 8
+EXIT_NETWORK = 70
+EXIT_SERVER = 75
+
+
+@dataclass
+class CliError(Exception):
+    code: str
+    message: str
+    details: dict[str, Any] = field(default_factory=dict)
+    exit_code: int = EXIT_USAGE
+
+    def __str__(self) -> str:
+        return self.message