guzli-cli 0.2.0__py3-none-any.whl

guzli/config_store.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import json
+import os
+import stat
+from collections.abc import Mapping
+from contextlib import suppress
+from dataclasses import dataclass
+from pathlib import Path
+
+from guzli.errors import ConfigError
+
+CONFIG_DIR_ENV = "GUZLI_CONFIG_DIR"
+DEFAULT_CONFIG_DIR = Path.home() / ".guzli"
+CONFIG_FILE_NAME = "config.json"
+
+
+@dataclass(frozen=True)
+class StoredProfile:
+    name: str
+    base_url: str | None = None
+    api_key: str | None = None
+    # Engine-issued access token, or a manually pasted JWT for the legacy workflow.
+    bearer_token: str | None = None
+    # Opaque refresh handle returned by /auth/cli/oauth/exchange.
+    # before bearer_token expires. Rotates on every refresh — must save the new value back.
+    refresh_handle: str | None = None
+    # ISO-8601 datetime of bearer_token expiry. Used to decide when to call /refresh.
+    access_token_expires_at: str | None = None
+    # Connected CLI session id from CliOAuthSessionResponse.id. Surfaced for debugging
+    # ("which connected client am I?") and so `auth status` can show it.
+    cli_session_id: str | None = None
+    agent_id: str | None = None
+    organization_id: str | None = None
+    default_number_pool_id: str | None = None
+    timeout_seconds: int | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        data: dict[str, object] = {}
+        if self.base_url:
+            data["base_url"] = self.base_url
+        if self.api_key:
+            data["api_key"] = self.api_key
+        if self.bearer_token:
+            data["bearer_token"] = self.bearer_token
+        if self.refresh_handle:
+            data["refresh_handle"] = self.refresh_handle
+        if self.access_token_expires_at:
+            data["access_token_expires_at"] = self.access_token_expires_at
+        if self.cli_session_id:
+            data["cli_session_id"] = self.cli_session_id
+        if self.agent_id:
+            data["agent_id"] = self.agent_id
+        if self.organization_id:
+            data["organization_id"] = self.organization_id
+        if self.default_number_pool_id:
+            data["default_number_pool_id"] = self.default_number_pool_id
+        if self.timeout_seconds is not None:
+            data["timeout_seconds"] = self.timeout_seconds
+        return data
+
+
+def _config_dir() -> Path:
+    override = os.getenv(CONFIG_DIR_ENV)
+    return Path(override) if override else DEFAULT_CONFIG_DIR
+
+
+def _config_path() -> Path:
+    return _config_dir() / CONFIG_FILE_NAME
+
+
+class ConfigStore:
+    """Read/write profile credentials at ~/.guzli/config.json."""
+
+    def __init__(self, path: Path | None = None) -> None:
+        self._path = path or _config_path()
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    def exists(self) -> bool:
+        return self._path.is_file()
+
+    def load_raw(self) -> dict[str, object]:
+        if not self._path.is_file():
+            return {"active_profile": None, "profiles": {}}
+        try:
+            with self._path.open("r", encoding="utf-8") as handle:
+                data = json.load(handle)
+        except (OSError, json.JSONDecodeError) as exc:
+            raise ConfigError(f"Could not read {self._path}: {exc}") from exc
+        if not isinstance(data, dict):
+            raise ConfigError(f"{self._path} must contain a JSON object")
+        profiles = data.get("profiles")
+        if not isinstance(profiles, dict):
+            data["profiles"] = {}
+        if data.get("active_profile") is not None and not isinstance(data["active_profile"], str):
+            data["active_profile"] = None
+        return data
+
+    def list_profiles(self) -> list[str]:
+        raw = self.load_raw()
+        profiles = raw.get("profiles")
+        return sorted(profiles.keys()) if isinstance(profiles, dict) else []
+
+    def active_profile_name(self) -> str | None:
+        raw = self.load_raw()
+        name = raw.get("active_profile")
+        return name if isinstance(name, str) else None
+
+    def get_profile(self, profile_name: str | None = None) -> StoredProfile | None:
+        raw = self.load_raw()
+        profiles = raw.get("profiles")
+        if not isinstance(profiles, dict):
+            return None
+        name = profile_name or raw.get("active_profile")
+        if not isinstance(name, str) or name not in profiles:
+            return None
+        entry = profiles[name]
+        if not isinstance(entry, Mapping):
+            return None
+        return StoredProfile(
+            name=name,
+            base_url=_string_or_none(entry.get("base_url")),
+            api_key=_string_or_none(entry.get("api_key")),
+            bearer_token=_string_or_none(entry.get("bearer_token")),
+            refresh_handle=_string_or_none(entry.get("refresh_handle")),
+            access_token_expires_at=_string_or_none(entry.get("access_token_expires_at")),
+            cli_session_id=_string_or_none(entry.get("cli_session_id")),
+            agent_id=_string_or_none(entry.get("agent_id")),
+            organization_id=_string_or_none(entry.get("organization_id")),
+            default_number_pool_id=_string_or_none(entry.get("default_number_pool_id")),
+            timeout_seconds=_int_or_none(entry.get("timeout_seconds")),
+        )
+
+    def save_profile(self, profile: StoredProfile, *, set_active: bool = True) -> None:
+        raw = self.load_raw()
+        profiles = raw.get("profiles")
+        if not isinstance(profiles, dict):
+            profiles = {}
+        profiles[profile.name] = profile.to_dict()
+        raw["profiles"] = profiles
+        if set_active or not raw.get("active_profile"):
+            raw["active_profile"] = profile.name
+        self._write(raw)
+
+    def set_active(self, profile_name: str) -> None:
+        raw = self.load_raw()
+        profiles = raw.get("profiles")
+        if not isinstance(profiles, dict):
+            raise ConfigError(f"Unknown profile: {profile_name}")
+        if profile_name not in profiles:
+            raise ConfigError(f"Unknown profile: {profile_name}")
+        raw["active_profile"] = profile_name
+        self._write(raw)
+
+    def delete_profile(self, profile_name: str) -> bool:
+        raw = self.load_raw()
+        profiles = raw.get("profiles")
+        if not isinstance(profiles, dict) or profile_name not in profiles:
+            return False
+        profiles.pop(profile_name)
+        if raw.get("active_profile") == profile_name:
+            raw["active_profile"] = next(iter(profiles), None)
+        self._write(raw)
+        return True
+
+    def clear_all(self) -> bool:
+        if not self._path.is_file():
+            return False
+        try:
+            self._path.unlink()
+        except OSError as exc:
+            raise ConfigError(f"Could not delete {self._path}: {exc}") from exc
+        return True
+
+    def _write(self, raw: Mapping[str, object]) -> None:
+        directory = self._path.parent
+        try:
+            directory.mkdir(parents=True, exist_ok=True)
+            with suppress(OSError):
+                os.chmod(directory, stat.S_IRWXU)
+            with self._path.open("w", encoding="utf-8") as handle:
+                json.dump(raw, handle, indent=2, sort_keys=True)
+                handle.write("\n")
+            with suppress(OSError):
+                os.chmod(self._path, stat.S_IRUSR | stat.S_IWUSR)
+        except OSError as exc:
+            raise ConfigError(f"Could not write {self._path}: {exc}") from exc
+
+
+def mask_secret(value: str | None) -> str:
+    if not value:
+        return "(unset)"
+    if len(value) <= 8:
+        return "***"
+    return f"{value[:4]}…{value[-4:]}"
+
+
+def _string_or_none(value: object) -> str | None:
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    return None
+
+
+def _int_or_none(value: object) -> int | None:
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, int) and value > 0:
+        return value
+    if isinstance(value, str):
+        try:
+            parsed = int(value)
+        except ValueError:
+            return None
+        return parsed if parsed > 0 else None
+    return None

guzli/errors.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+
+class GuzliSkillError(Exception):
+    """Base error for Guzli skill."""
+
+
+class ConfigError(GuzliSkillError):
+    """Raised when required configuration is missing or invalid."""
+
+
+class ValidationError(GuzliSkillError):
+    """Raised when input validation fails."""
+
+
+class ApiError(GuzliSkillError):
+    """Raised when the API returns a non-success response."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: int | None = None,
+        detail: str | None = None,
+        *,
+        code: str | None = None,
+        request_id: str | None = None,
+        retry_after: str | None = None,
+        retryable: bool = False,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.detail = detail
+        self.code = code
+        self.request_id = request_id
+        self.retry_after = retry_after
+        self.retryable = retryable
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "code": self.code or "api_error",
+            "message": str(self),
+            "detail": self.detail,
+            "status_code": self.status_code,
+            "request_id": self.request_id,
+            "retry_after": self.retry_after,
+            "retryable": self.retryable,
+        }

guzli/http_client.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+from guzli.auth import AuthCapability, AuthSelector
+from guzli.errors import ApiError, ConfigError
+from guzli.types import JsonValue
+from guzli.validators import require_non_empty
+
+
+@dataclass
+class HttpClient:
+    base_url: str
+    auth_selector: AuthSelector
+    timeout_seconds: int
+    agent_id: str | None
+    # Scriptable credential routes require this as X-Organization-ID.
+    organization_id: str | None = None
+    _session: Any = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        requests = _load_requests()
+        from requests.adapters import HTTPAdapter
+        from urllib3.util import Retry
+
+        retry = Retry(
+            total=2,
+            connect=2,
+            read=2,
+            status=2,
+            backoff_factor=0.25,
+            status_forcelist=(429, 500, 502, 503, 504),
+            allowed_methods=frozenset({"GET", "HEAD", "OPTIONS"}),
+            respect_retry_after_header=True,
+            raise_on_status=False,
+        )
+        self._session = requests.Session()
+        adapter = HTTPAdapter(max_retries=retry)
+        self._session.mount("https://", adapter)
+        self._session.mount("http://", adapter)
+
+    def request_unauthenticated_json(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Mapping[str, object] | None = None,
+        payload: JsonValue | None = None,
+    ) -> JsonValue:
+        """For endpoints that take their credential in the request body (e.g. the OAuth
+        refresh / exchange / logout endpoints take `refresh_handle` in the body and reject
+        Authorization headers). Skips auth_selector entirely to avoid bootstrap issues
+        when no credential is configured yet (e.g. during `auth login --mode oauth`)."""
+        return self._send(method, path, params=params, payload=payload, extra_headers={})
+
+    def request_json(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Mapping[str, object] | None = None,
+        payload: JsonValue | None = None,
+        require_user: bool = False,
+        auth_capability: AuthCapability | None = None,
+        require_agent: bool = False,
+        require_organization: bool = False,
+    ) -> JsonValue:
+        capability = auth_capability
+        if capability is None:
+            capability = (
+                AuthCapability.BEARER_ONLY if require_user else AuthCapability.API_KEY_OR_BEARER
+            )
+        auth_headers = self.auth_selector.select(capability).headers()
+        extra: dict[str, str] = dict(auth_headers)
+        if require_agent:
+            agent_id = require_non_empty(self.agent_id, "GUZLI_AGENT_ID")
+            extra["x-agent-id"] = agent_id
+        elif self.agent_id:
+            extra["x-agent-id"] = self.agent_id
+        if require_organization:
+            org_id = require_non_empty(self.organization_id, "GUZLI_ORGANIZATION_ID")
+            extra["x-organization-id"] = org_id
+        elif self.organization_id:
+            extra["x-organization-id"] = self.organization_id
+        return self._send(method, path, params=params, payload=payload, extra_headers=extra)
+
+    def _send(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Mapping[str, object] | None,
+        payload: JsonValue | None,
+        extra_headers: dict[str, str],
+    ) -> JsonValue:
+        requests = _load_requests()
+        request_id = uuid4().hex
+        headers: dict[str, str] = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": "guzli-cli/0.2",
+            "X-Request-ID": request_id,
+        }
+        headers.update(extra_headers)
+        url = _join_url(self.base_url, path)
+        try:
+            response = self._session.request(
+                method=method,
+                url=url,
+                headers=headers,
+                params=_normalize_params(params),
+                json=payload,
+                timeout=self.timeout_seconds,
+            )
+        except requests.RequestException as exc:
+            raise ApiError(
+                "Network error while calling Guzli API",
+                code="network_error",
+                request_id=request_id,
+                retryable=method.upper() in {"GET", "HEAD", "OPTIONS"},
+            ) from exc
+
+        if response.ok:
+            return _parse_json(response)
+
+        detail = _extract_error_detail(response)
+        response_request_id = (
+            response.headers.get("X-Request-ID")
+            or response.headers.get("X-Correlation-ID")
+            or request_id
+        )
+        retry_after = response.headers.get("Retry-After")
+        error_code = _extract_error_code(response)
+        raise ApiError(
+            f"Guzli API request failed ({response.status_code})",
+            status_code=response.status_code,
+            detail=detail,
+            code=error_code,
+            request_id=response_request_id,
+            retry_after=retry_after,
+            retryable=response.status_code in {408, 425, 429, 500, 502, 503, 504},
+        )
+
+
+def _join_url(base_url: str, path: str) -> str:
+    if not base_url:
+        raise ConfigError("GUZLI_API_BASE_URL is required")
+    base = base_url.rstrip("/")
+    suffix = path if path.startswith("/") else f"/{path}"
+    return f"{base}{suffix}"
+
+
+def _normalize_params(
+    params: Mapping[str, object] | None,
+) -> dict[str, Iterable[str] | str] | None:
+    if not params:
+        return None
+    normalized: dict[str, Iterable[str] | str] = {}
+    for key, value in params.items():
+        if value is None:
+            continue
+        if isinstance(value, list):
+            normalized[key] = [str(item) for item in value if item is not None]
+        else:
+            normalized[key] = str(value)
+    return normalized
+
+
+def _parse_json(response: Any) -> JsonValue:
+    if not response.content:
+        return None
+    try:
+        return response.json()
+    except ValueError:
+        return response.text
+
+
+def _extract_error_detail(response: Any) -> str | None:
+    try:
+        payload = response.json()
+    except ValueError:
+        payload = None
+    if isinstance(payload, dict):
+        detail = payload.get("detail") or payload.get("message")
+        if isinstance(detail, str):
+            return detail
+        return response.text
+    if isinstance(payload, list):
+        return response.text
+    return response.text
+
+
+def _extract_error_code(response: Any) -> str:
+    try:
+        payload = response.json()
+    except ValueError:
+        payload = None
+    if isinstance(payload, dict):
+        code = payload.get("code") or payload.get("error_code")
+        if isinstance(code, str) and code.strip():
+            return code.strip()
+    return f"http_{response.status_code}"
+
+
+def _load_requests():
+    try:
+        import requests
+    except ImportError as exc:  # pragma: no cover - runtime dependency
+        raise ConfigError("requests library not found. Install with: pip install requests") from exc
+    return requests

guzli/mcp/__init__.py

@@ -0,0 +1 @@
+"""Guzli Model Context Protocol server package."""