deepflow-opendesk-cli 0.1.0__py3-none-any.whl

deepflow_opendesk_cli/client.py

@@ -0,0 +1,323 @@
+"""HTTP client and request helpers for OpenDesk configuration APIs."""
+
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode, urlparse
+from urllib.request import Request, urlopen
+
+DEFAULT_HOST = "http://localhost:5001"
+ENV_HOST = "OPENDESK_HOST"
+ENV_BASE_URL = "OPENDESK_BASE_URL"
+ENV_TOKEN = "OPENDESK_TOKEN"
+API_PREFIX = "/api/v1"
+
+
+class CliError(Exception):
+    """Expected CLI error with a user-facing message."""
+
+
+@dataclass(frozen=True)
+class HttpResult:
+    """Structured HTTP result for JSON output."""
+
+    ok: bool
+    status: int | None
+    method: str
+    path: str
+    url: str
+    data: Any = None
+    error: str | None = None
+    body: Any = None
+    dry_run: bool = False
+    curl: str | None = None
+    raw_text: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return a compact JSON-serializable result."""
+        result: dict[str, Any] = {
+            "ok": self.ok,
+            "status": self.status,
+            "method": self.method,
+            "path": self.path,
+        }
+        if self.dry_run:
+            result["dry_run"] = True
+        if self.data is not None:
+            result["data"] = self.data
+        if self.error:
+            result["error"] = self.error
+        if self.body is not None:
+            result["body"] = self.body
+        if self.curl:
+            result["curl"] = self.curl
+        return result
+
+
+class OpenDeskClient:
+    """Small urllib-based HTTP client for OpenDesk."""
+
+    def __init__(self, host: str = DEFAULT_HOST, token: str | None = None, timeout: int = 30) -> None:
+        self.host = normalize_host(host)
+        self.token = token
+        self.timeout = timeout
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: dict[str, Any] | None = None,
+        body: dict[str, Any] | None = None,
+        files: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        dry_run: bool = False,
+        emit_curl: bool = False,
+    ) -> HttpResult:
+        """Send an HTTP request or return a dry-run representation."""
+        method = method.upper()
+        url = self.build_url(path, query or {})
+        req_headers = {"Accept": "application/json"}
+        if self.token:
+            req_headers["Authorization"] = f"Bearer {self.token}"
+        if headers:
+            req_headers.update(headers)
+
+        data = None
+        if body is not None and files:
+            raise CliError("JSON body and multipart files cannot be used together")
+        if body is not None:
+            data = json.dumps(body, ensure_ascii=False).encode("utf-8")
+            req_headers["Content-Type"] = "application/json"
+        elif files:
+            data, content_type = encode_multipart(files)
+            req_headers["Content-Type"] = content_type
+
+        curl = emit_curl_command(method, url, req_headers, body, files) if emit_curl else None
+        if dry_run:
+            return HttpResult(
+                ok=True,
+                status=None,
+                method=method,
+                path=path,
+                url=url,
+                data={
+                    "query": query or {},
+                    "body": body,
+                    "files": files or {},
+                    "headers": redact_headers(req_headers),
+                },
+                dry_run=True,
+                curl=curl,
+            )
+
+        request = Request(url, data=data, headers=req_headers, method=method)
+        try:
+            with urlopen(request, timeout=self.timeout) as response:  # noqa: S310 - CLI calls user-provided hosts.
+                raw = response.read().decode("utf-8", errors="replace")
+                parsed = parse_response_body(raw)
+                return HttpResult(
+                    ok=True,
+                    status=response.status,
+                    method=method,
+                    path=path,
+                    url=url,
+                    data=parsed,
+                    raw_text=raw,
+                    curl=curl,
+                )
+        except HTTPError as exc:
+            raw = exc.read().decode("utf-8", errors="replace")
+            parsed = parse_response_body(raw)
+            return HttpResult(
+                ok=False,
+                status=exc.code,
+                method=method,
+                path=path,
+                url=url,
+                error=f"HTTP {exc.code}",
+                body=parsed,
+                raw_text=raw,
+                curl=curl,
+            )
+        except URLError as exc:
+            raise CliError(f"Failed to connect to {url}: {exc.reason}") from exc
+
+    def build_url(self, path: str, query: dict[str, Any] | None = None) -> str:
+        """Build a full URL from a path and query parameters."""
+        if path.startswith("http://") or path.startswith("https://"):
+            base = path
+        else:
+            normalized_path = path if path.startswith("/") else f"/{path}"
+            base = f"{self.host}{normalized_path}"
+        clean_query = {
+            key: value
+            for key, value in (query or {}).items()
+            if value is not None and value is not False
+        }
+        suffix = f"?{urlencode(clean_query, doseq=True)}" if clean_query else ""
+        return f"{base}{suffix}"
+
+
+def normalize_host(value: str | None) -> str:
+    """Normalize an API host or base URL to a host without trailing slash."""
+    raw = (value or DEFAULT_HOST).rstrip("/")
+    if raw.endswith(API_PREFIX):
+        raw = raw[: -len(API_PREFIX)]
+    parsed = urlparse(raw)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise CliError(f"Invalid OpenDesk host: {value}")
+    return raw
+
+
+def host_from_env_or_profile(
+    *,
+    host: str | None = None,
+    base_url: str | None = None,
+    profile_data: dict[str, Any] | None = None,
+) -> str:
+    """Resolve host from flags, env, profile, or default."""
+    selected = (
+        host
+        or base_url
+        or os.getenv(ENV_HOST)
+        or os.getenv(ENV_BASE_URL)
+        or (profile_data or {}).get("host")
+        or DEFAULT_HOST
+    )
+    return normalize_host(str(selected))
+
+
+def token_from_env_or_profile(
+    *,
+    token: str | None = None,
+    profile_data: dict[str, Any] | None = None,
+) -> str | None:
+    """Resolve token from flags, env, or profile."""
+    return token or os.getenv(ENV_TOKEN) or (profile_data or {}).get("token")
+
+
+def load_json_payload(json_text: str | None, json_file: str | None) -> dict[str, Any]:
+    """Load an object JSON payload from text or file."""
+    if json_text and json_file:
+        raise CliError("--json and --json-file cannot be used together")
+    if not json_text and not json_file:
+        return {}
+    source = json_text
+    if json_file:
+        source = Path(json_file).read_text(encoding="utf-8")
+    try:
+        payload = json.loads(source or "{}")
+    except json.JSONDecodeError as exc:
+        raise CliError(f"Invalid JSON at line {exc.lineno}, column {exc.colno}: {exc.msg}") from exc
+    if not isinstance(payload, dict):
+        raise CliError("JSON payload must be an object")
+    return payload
+
+
+def parse_key_value(items: list[str] | None) -> dict[str, Any]:
+    """Parse repeated key=value arguments into a dictionary."""
+    result: dict[str, Any] = {}
+    for item in items or []:
+        if "=" not in item:
+            raise CliError(f"Expected key=value, got: {item}")
+        key, value = item.split("=", 1)
+        if not key:
+            raise CliError(f"Expected non-empty key in: {item}")
+        if key in result:
+            current = result[key]
+            if isinstance(current, list):
+                current.append(value)
+            else:
+                result[key] = [current, value]
+        else:
+            result[key] = value
+    return result
+
+
+def parse_response_body(raw: str) -> Any:
+    """Parse a response body as JSON when possible."""
+    if raw == "":
+        return None
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        return raw
+
+
+def print_result(result: HttpResult, *, pretty: bool = True, raw: bool = False) -> None:
+    """Print a result to stdout."""
+    if raw:
+        text = result.raw_text
+        if text is None:
+            text = "" if result.data is None else json.dumps(result.data, ensure_ascii=False)
+        print(text, end="" if text.endswith("\n") else "\n")
+        return
+    payload = result.to_dict()
+    if pretty:
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+    else:
+        print(json.dumps(payload, ensure_ascii=False, separators=(",", ":")))
+
+
+def print_json(data: Any, *, pretty: bool = True) -> None:
+    """Print JSON data to stdout."""
+    if pretty:
+        print(json.dumps(data, ensure_ascii=False, indent=2))
+    else:
+        print(json.dumps(data, ensure_ascii=False, separators=(",", ":")))
+
+
+def redact_headers(headers: dict[str, str]) -> dict[str, str]:
+    """Redact sensitive headers for output."""
+    redacted = dict(headers)
+    if "Authorization" in redacted:
+        redacted["Authorization"] = "Bearer ***"
+    return redacted
+
+
+def emit_curl_command(
+    method: str,
+    url: str,
+    headers: dict[str, str],
+    body: dict[str, Any] | None,
+    files: dict[str, str] | None = None,
+) -> str:
+    """Build a curl command with sensitive values redacted."""
+    parts = ["curl", "-X", method, shlex.quote(url)]
+    for key, value in redact_headers(headers).items():
+        parts.extend(["-H", shlex.quote(f"{key}: {value}")])
+    if body is not None:
+        parts.extend(["-d", shlex.quote(json.dumps(body, ensure_ascii=False))])
+    for field, path in (files or {}).items():
+        parts.extend(["-F", shlex.quote(f"{field}=@{path}")])
+    return " ".join(parts)
+
+
+def encode_multipart(files: dict[str, str]) -> tuple[bytes, str]:
+    """Encode file fields as multipart/form-data."""
+    boundary = f"----opendesk-cli-{uuid.uuid4().hex}"
+    chunks: list[bytes] = []
+    for field, file_path in files.items():
+        path = Path(file_path)
+        if not path.is_file():
+            raise CliError(f"File not found: {file_path}")
+        chunks.append(f"--{boundary}\r\n".encode("utf-8"))
+        chunks.append(
+            (
+                f'Content-Disposition: form-data; name="{field}"; '
+                f'filename="{path.name}"\r\n'
+                "Content-Type: application/octet-stream\r\n\r\n"
+            ).encode("utf-8")
+        )
+        chunks.append(path.read_bytes())
+        chunks.append(b"\r\n")
+    chunks.append(f"--{boundary}--\r\n".encode("utf-8"))
+    return b"".join(chunks), f"multipart/form-data; boundary={boundary}"

deepflow_opendesk_cli/profiles.py

@@ -0,0 +1,91 @@
+"""Local profile storage for OpenDesk CLI credentials and schema cache."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+CONFIG_HOME_ENV = "OPENDESK_CONFIG_HOME"
+DEFAULT_PROFILE = "default"
+
+
+def config_home() -> Path:
+    """Return the base directory used for CLI profiles."""
+    override = os.getenv(CONFIG_HOME_ENV)
+    if override:
+        return Path(override).expanduser()
+    return Path.home() / ".opendesk" / "cli"
+
+
+def profile_dir(profile: str = DEFAULT_PROFILE) -> Path:
+    """Return a profile directory path without creating it."""
+    return config_home() / profile
+
+
+def profile_path(profile: str = DEFAULT_PROFILE) -> Path:
+    """Return the profile JSON path."""
+    return profile_dir(profile) / "profile.json"
+
+
+def schema_cache_path(profile: str = DEFAULT_PROFILE) -> Path:
+    """Return the cached OpenAPI schema path."""
+    return profile_dir(profile) / "openapi.json"
+
+
+def _secure_parent(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        os.chmod(path.parent, 0o700)
+    except OSError:
+        pass
+
+
+def read_json(path: Path) -> dict[str, Any] | None:
+    """Read a JSON object if the file exists."""
+    if not path.exists():
+        return None
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError(f"{path} must contain a JSON object")
+    return data
+
+
+def write_json(path: Path, data: dict[str, Any]) -> None:
+    """Write a JSON object with owner-only permissions where supported."""
+    _secure_parent(path)
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+
+
+def load_profile(profile: str = DEFAULT_PROFILE) -> dict[str, Any] | None:
+    """Load a saved CLI profile."""
+    return read_json(profile_path(profile))
+
+
+def save_profile(profile: str, data: dict[str, Any]) -> None:
+    """Save a CLI profile."""
+    write_json(profile_path(profile), data)
+
+
+def delete_profile(profile: str = DEFAULT_PROFILE) -> bool:
+    """Delete a saved CLI profile, returning whether a file was removed."""
+    path = profile_path(profile)
+    if not path.exists():
+        return False
+    path.unlink()
+    return True
+
+
+def save_schema_cache(profile: str, schema: dict[str, Any]) -> None:
+    """Save the OpenAPI schema cache for a profile."""
+    write_json(schema_cache_path(profile), schema)
+
+
+def load_schema_cache(profile: str = DEFAULT_PROFILE) -> dict[str, Any] | None:
+    """Load the cached OpenAPI schema for a profile."""
+    return read_json(schema_cache_path(profile))