socaity-cli 0.1.1__py3-none-any.whl

socaity_cli/credentials.py

@@ -0,0 +1,128 @@
+"""XDG credentials storage for the Socaity CLI."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+DEFAULT_BACKEND_URL = "https://webapi.socaity.ai"
+DEFAULT_FRONTEND_URL = "https://socaity.ai"
+
+_LEGACY_TOKEN_FILE = Path.home() / ".apipod" / "token"
+
+
+@dataclass
+class Credentials:
+    api_key: str
+    user_id: Optional[str] = None
+    user_email: Optional[str] = None
+    backend_url: str = DEFAULT_BACKEND_URL
+    logged_in_at: Optional[str] = None
+
+    def apply_to_env(self) -> None:
+        # setdefault: an explicitly set env var (e.g. pointing at a local
+        # backend) always wins over stored credentials.
+        os.environ.setdefault("SOCAITY_API_KEY", self.api_key)
+        os.environ.setdefault("SOCAITY_BACKEND_URL", self.backend_url.rstrip("/") + "/")
+
+
+def config_dir() -> Path:
+    xdg = os.environ.get("XDG_CONFIG_HOME", "").strip()
+    base = Path(xdg) if xdg else Path.home() / ".config"
+    return base / "socaity"
+
+
+def credentials_path() -> Path:
+    return config_dir() / "credentials.json"
+
+
+def load_credentials() -> Optional[Credentials]:
+    path = credentials_path()
+    if path.is_file():
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            api_key = (data.get("api_key") or "").strip()
+            if api_key:
+                return Credentials(
+                    api_key=api_key,
+                    user_id=data.get("user_id"),
+                    user_email=data.get("user_email"),
+                    backend_url=(data.get("backend_url") or DEFAULT_BACKEND_URL).rstrip("/"),
+                    logged_in_at=data.get("logged_in_at"),
+                )
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    legacy = _load_legacy_token()
+    if legacy:
+        save_credentials(legacy)
+        return legacy
+    return None
+
+
+def _load_legacy_token() -> Optional[Credentials]:
+    if not _LEGACY_TOKEN_FILE.is_file():
+        return None
+    try:
+        token = _LEGACY_TOKEN_FILE.read_text(encoding="utf-8").strip()
+        if not token:
+            return None
+        backend = os.environ.get("SOCAITY_BACKEND_URL", DEFAULT_BACKEND_URL).rstrip("/")
+        return Credentials(
+            api_key=token,
+            backend_url=backend,
+            logged_in_at=datetime.now(timezone.utc).isoformat(),
+        )
+    except OSError:
+        return None
+
+
+def save_credentials(credentials: Credentials) -> Path:
+    directory = config_dir()
+    directory.mkdir(parents=True, exist_ok=True)
+    path = credentials_path()
+    payload: dict[str, Any] = asdict(credentials)
+    payload["backend_url"] = credentials.backend_url.rstrip("/")
+    if not payload.get("logged_in_at"):
+        payload["logged_in_at"] = datetime.now(timezone.utc).isoformat()
+    path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    path.chmod(0o600)
+    credentials.apply_to_env()
+    return path
+
+
+def clear_credentials() -> bool:
+    path = credentials_path()
+    if path.is_file():
+        path.unlink()
+        return True
+    return False
+
+
+def get_api_key() -> Optional[str]:
+    """Return the active API key. Explicit ``SOCAITY_API_KEY`` wins over login file."""
+    env_key = os.environ.get("SOCAITY_API_KEY", "").strip()
+    if env_key:
+        return env_key
+    creds = load_credentials()
+    if creds:
+        creds.apply_to_env()
+        return creds.api_key
+    return None
+
+
+def require_credentials() -> Credentials:
+    stored = load_credentials()
+    if stored:
+        stored.apply_to_env()
+        return stored
+    env_key = os.environ.get("SOCAITY_API_KEY", "").strip()
+    if env_key:
+        backend = os.environ.get("SOCAITY_BACKEND_URL", DEFAULT_BACKEND_URL).rstrip("/")
+        return Credentials(api_key=env_key, backend_url=backend)
+    print("Not logged in. Run: socaity login (or set SOCAITY_API_KEY).")
+    raise SystemExit(1)

socaity_cli/deployment.py

@@ -0,0 +1,349 @@
+"""Socaity platform deployment helpers (analyze, draft, HF token prompts).
+
+Used by ``apipod deploy`` and ``socaity deploy``.
+Requires login; apipod scan/build/start work without the backend.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, Optional
+
+from socaity_cli.backend_client import SocaityBackendClient
+from socaity_cli.credentials import require_credentials
+from socaity_cli.errors import PrivateSlotLimitError
+from socaity_cli.prompts import input_yes_no
+from socaity_cli.registry_push import (
+    CredentialsExpired,
+    DockerNotAvailable,
+    PushFailed,
+    image_size_bytes,
+    push_image,
+)
+
+_TERMINAL_STATUSES = frozenset({
+    "live",
+    "failed_push",
+    "failed_validation",
+    "failed_provision",
+    "cancelled",
+})
+_POLL_INTERVAL_S = 5.0
+_DEFAULT_TIMEOUT_S = 3600.0
+
+
+def print_analysis_report(report: Dict[str, Any]) -> None:
+    """Render a backend analysis payload for the terminal."""
+    for model in report.get("models", []):
+        ref = model.get("ref", "?")
+        status = model.get("hf_status", "unknown")
+        line = f"  {ref}: {status}"
+        catalog = model.get("catalog_match")
+        if catalog:
+            vram = (catalog.get("min_gpu_vram_gb") and f", needs ~{catalog['min_gpu_vram_gb']} GB VRAM") or ""
+            line += f" | catalog: {catalog.get('name')}{vram}"
+        print(line)
+        for warning in model.get("warnings", []):
+            print(f"    warning: {warning}")
+    gpu = report.get("recommended_gpu")
+    if gpu:
+        print(f"  Recommended GPU tier: {gpu}")
+    for service in report.get("similar_services", []):
+        name = service.get("display_name") or service.get("name")
+        print(f"  Similar public service: {name} (id={service.get('id')})")
+    for warning in report.get("warnings", []):
+        print(f"  warning: {warning}")
+
+
+def analyze_deployment(config: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Run backend analysis. Returns None on failure."""
+    require_credentials()
+    client = SocaityBackendClient()
+    print("Analyzing deployment against the Socaity catalog...")
+    report = client.analyze_deployment(config)
+    if report is None:
+        print("Analysis failed. Check your connection and login (socaity login), then retry.")
+        return None
+    print_analysis_report(report)
+    return report
+
+
+def prompt_model_resolutions(report: Dict[str, Any]) -> Dict[str, Optional[str]]:
+    """Ask the user to confirm fuzzy catalog matches for declared HF models.
+
+    Returns HF ref -> catalog model id (confirmed candidate) or None (create
+    a new catalog entry). Exact matches need no confirmation and are omitted.
+    """
+    resolutions: Dict[str, Optional[str]] = {}
+    for model in report.get("models", []):
+        ref = model.get("ref")
+        if not ref or model.get("catalog_match") or model.get("hf_status") in ("invalid", "not_found"):
+            continue
+        candidates = model.get("candidates") or []
+        picked = None
+        for candidate in candidates:
+            label = candidate.get("display_name") or candidate.get("name")
+            hf_url = candidate.get("hugging_face_url")
+            hint = f" ({hf_url})" if hf_url else ""
+            if input_yes_no(f"  {ref}: we found '{label}'{hint} in our catalog. Is this your model?"):
+                picked = candidate.get("id")
+                break
+        if picked is None:
+            print(f"  {ref}: will be added to the Socaity model catalog.")
+        resolutions[ref] = picked
+    return resolutions
+
+
+def prompt_gated_hf_token(client: SocaityBackendClient, report: Dict[str, Any]) -> None:
+    """Offer to store an HF token when gated repos were detected."""
+    gated = [
+        m["ref"]
+        for m in report.get("models", [])
+        if m.get("hf_status") == "gated" and not report.get("has_hf_token")
+    ]
+    if not gated:
+        return
+    print(f"\nGated Hugging Face repos detected: {', '.join(gated)}")
+    if not input_yes_no("Store a Hugging Face access token now?"):
+        return
+    token = input("HF token (hf_...): ").strip()
+    if token and client.upsert_hf_token(token):
+        print("Token stored. It will be attached to your deployment.")
+    else:
+        print("Token not stored; gated repos will fail to download on deploy.")
+
+
+def create_deployment_draft(config: Dict[str, Any], report: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
+    """Create a deployment draft after optional confirmation."""
+    require_credentials()
+    client = SocaityBackendClient()
+    if report is None:
+        report = client.analyze_deployment(config)
+        if report is None:
+            print("Analysis failed. Draft not created.")
+            return None
+        print_analysis_report(report)
+
+    resolutions = prompt_model_resolutions(report)
+    prompt_gated_hf_token(client, report)
+
+    if not input_yes_no("\nCreate a deployment draft on Socaity?"):
+        print("Aborted. Nothing was created.")
+        return None
+
+    try:
+        draft = client.create_deployment_draft(config, model_resolutions=resolutions)
+    except PrivateSlotLimitError as exc:
+        print(f"\n{exc}")
+        print("Tip: publish a private service from the service page, or upgrade your plan.")
+        raise
+    if draft is None:
+        print("Draft creation failed.")
+        return None
+    print(
+        f"Draft created: service_id={draft.get('service_id')} deployment_id={draft.get('deployment_id')}\n"
+        "Next: the image will be pushed to the Socaity registry and provisioned automatically."
+    )
+    return draft
+
+
+def push_image_to_registry(
+    deployment_id: str,
+    local_tag: str,
+    *,
+    client: Optional[SocaityBackendClient] = None,
+) -> Optional[str]:
+    """Push a local image to the deployment staging repo. Returns the manifest digest."""
+    client = client or SocaityBackendClient()
+    estimated_size = image_size_bytes(local_tag)
+    creds = client.get_push_credentials(deployment_id, estimated_size_bytes=estimated_size)
+    if creds is None:
+        print("Could not obtain registry push credentials.")
+        return None
+
+    for attempt in range(2):
+        try:
+            digest, _size = push_image(
+                registry=creds["registry"],
+                repository=creds["repository"],
+                tag=creds.get("tag", "build"),
+                username=creds["username"],
+                password=creds["password"],
+                local_tag=local_tag,
+            )
+            return digest
+        except CredentialsExpired:
+            if attempt == 0:
+                print("Push credentials expired; requesting fresh credentials...")
+                creds = client.get_push_credentials(deployment_id, estimated_size_bytes=estimated_size)
+                if creds is None:
+                    print("Could not refresh registry push credentials.")
+                    return None
+                continue
+            print("Registry rejected the push credentials again.")
+            return None
+        except DockerNotAvailable as exc:
+            print(str(exc))
+            return None
+        except PushFailed as exc:
+            print(str(exc))
+            return None
+    return None
+
+
+def poll_deployment_until_terminal(
+    deployment_id: str,
+    *,
+    timeout_s: float = _DEFAULT_TIMEOUT_S,
+    client: Optional[SocaityBackendClient] = None,
+) -> Optional[Dict[str, Any]]:
+    """Poll pipeline status until live or a terminal failure."""
+    client = client or SocaityBackendClient()
+    deadline = time.monotonic() + timeout_s
+    last_status: Optional[Dict[str, Any]] = None
+
+    while time.monotonic() < deadline:
+        status = client.get_deployment_pipeline_status(deployment_id)
+        if status is None:
+            print("Pipeline status poll failed; retrying...")
+            time.sleep(_POLL_INTERVAL_S)
+            continue
+
+        last_status = status
+        phase = status.get("phase")
+        state = str(status.get("status", "")).lower()
+        label = f"{state}" + (f" ({phase})" if phase else "")
+        print(f"  deployment status: {label}")
+
+        if state in _TERMINAL_STATUSES:
+            return status
+        time.sleep(_POLL_INTERVAL_S)
+
+    print(f"Timed out after {int(timeout_s)}s waiting for deployment {deployment_id}.")
+    return last_status
+
+
+def _create_draft_with_prompts(
+    config: Dict[str, Any],
+    *,
+    client: SocaityBackendClient,
+    assume_yes: bool,
+) -> Optional[Dict[str, Any]]:
+    report = client.analyze_deployment(config)
+    if report is None:
+        print("Analysis failed. Draft not created.")
+        return None
+    print_analysis_report(report)
+
+    if assume_yes:
+        resolutions: Dict[str, Optional[str]] = {}
+        for model in report.get("models", []):
+            ref = model.get("ref")
+            if not ref or model.get("catalog_match"):
+                continue
+            candidates = model.get("candidates") or []
+            resolutions[ref] = candidates[0]["id"] if candidates else None
+    else:
+        resolutions = prompt_model_resolutions(report)
+
+    prompt_gated_hf_token(client, report)
+
+    if not assume_yes and not input_yes_no("\nCreate a deployment draft on Socaity?"):
+        print("Aborted. Nothing was created.")
+        return None
+
+    try:
+        draft = client.create_deployment_draft(config, model_resolutions=resolutions)
+    except PrivateSlotLimitError as exc:
+        print(f"\n{exc}")
+        print("Tip: publish a private service from the service page, or upgrade your plan.")
+        raise
+    if draft is None:
+        print("Draft creation failed.")
+        return None
+    print(
+        f"Draft created: service_id={draft.get('service_id')} "
+        f"deployment_id={draft.get('deployment_id')}"
+    )
+    return draft
+
+
+def run_full_deploy(
+    config: Dict[str, Any],
+    *,
+    local_tag: str,
+    resume_deployment_id: Optional[str] = None,
+    assume_yes: bool = False,
+) -> Optional[Dict[str, Any]]:
+    """Analyze → draft (unless resuming) → push → poll until live or failure."""
+    require_credentials()
+    client = SocaityBackendClient()
+
+    deployment_id = resume_deployment_id
+    if deployment_id:
+        status = client.get_deployment_pipeline_status(deployment_id)
+        if status is None:
+            print(f"Deployment {deployment_id} not found or not accessible.")
+            return None
+        state = str(status.get("status", "")).lower()
+        if state == "live":
+            print(f"Deployment {deployment_id} is already live.")
+            return status
+        if state in _TERMINAL_STATUSES - {"live"}:
+            print(
+                f"Deployment {deployment_id} is in terminal state '{state}'. "
+                "Create a new draft or fix the issue before resuming."
+            )
+            return status
+        print(f"Resuming deployment {deployment_id} (status={state}).")
+    else:
+        draft = _create_draft_with_prompts(config, client=client, assume_yes=assume_yes)
+        if draft is None:
+            return None
+        deployment_id = draft.get("deployment_id")
+        if not deployment_id:
+            print("Draft response did not include deployment_id.")
+            return None
+
+    current = client.get_deployment_pipeline_status(deployment_id) or {}
+    state = str(current.get("status", "")).lower()
+    if state in {"draft", "awaiting_image", "pushing", "failed_push"}:
+        print(f"Pushing image '{local_tag}' to the Socaity registry...")
+        digest = push_image_to_registry(deployment_id, local_tag, client=client)
+        if digest is None:
+            return None
+        size_bytes = image_size_bytes(local_tag)
+        pushed = client.confirm_image_pushed(deployment_id, digest=digest, size_bytes=size_bytes)
+        if pushed is None:
+            print("Backend did not accept the image push confirmation.")
+            return None
+        print(f"Image pushed (digest={digest}). Validation and provisioning started.")
+    elif state in {"validating", "promoting", "provisioning"}:
+        print(f"Image already pushed; waiting for pipeline (status={state}).")
+    elif state == "live":
+        print(f"Deployment {deployment_id} is already live.")
+        return current
+
+    print("Waiting for deployment to go live (this may take several minutes)...")
+    final = poll_deployment_until_terminal(deployment_id, client=client)
+    if final is None:
+        return None
+
+    final_state = str(final.get("status", "")).lower()
+    if final_state == "live":
+        print(f"\nDeployment live: deployment_id={deployment_id}")
+        if final.get("service_id"):
+            print(f"  service_id={final['service_id']}")
+        print("  https://www.socaity.ai")
+    elif final.get("error"):
+        print(f"\nDeployment failed: {final['error']}")
+    else:
+        print(f"\nDeployment ended with status={final_state}.")
+    return final
+
+
+def run_platform_deploy(config: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Full analyze → optional HF token → optional draft flow."""
+    report = analyze_deployment(config)
+    if report is None:
+        return None
+    return create_deployment_draft(config, report=report)

socaity_cli/errors.py

@@ -0,0 +1,35 @@
+"""CLI-facing structured API errors."""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class BackendApiError(Exception):
+    """HTTP error from the Socaity backend with optional structured detail."""
+
+    def __init__(
+        self,
+        status_code: int,
+        message: str,
+        *,
+        code: Optional[str] = None,
+        detail: Optional[Any] = None,
+    ):
+        self.status_code = status_code
+        self.code = code
+        self.detail = detail
+        super().__init__(message)
+
+
+class PrivateSlotLimitError(BackendApiError):
+    """Private deployment slot limit reached (plan quota)."""
+
+    def __init__(self, detail: dict):
+        used = detail.get("used")
+        limit = detail.get("limit")
+        plan = detail.get("plan") or "free"
+        message = detail.get("message") or (
+            f"Private deployment limit reached ({used}/{limit} on plan '{plan}'). "
+            "Publish an existing private service or upgrade your plan to free a slot."
+        )
+        super().__init__(403, message, code="PRIVATE_SLOT_LIMIT", detail=detail)

socaity_cli/http.py

@@ -0,0 +1,105 @@
+"""Shared HTTP transport for platform backend clients."""
+import json
+import os
+from typing import Any, Dict, Optional
+
+import httpx
+
+from socaity_cli.credentials import DEFAULT_BACKEND_URL, get_api_key
+from socaity_cli.errors import BackendApiError, PrivateSlotLimitError
+
+
+class BackendHttp:
+    """Base HTTP client: URL, Bearer auth, query flattening, JSON requests."""
+
+    def __init__(self, backend_url: Optional[str] = None, api_key: Optional[str] = None):
+        default_backend = DEFAULT_BACKEND_URL.rstrip("/") + "/"
+        self.backend_url = (backend_url or os.getenv("SOCAITY_BACKEND_URL", default_backend)).rstrip("/") + "/"
+        self.api_key = api_key if api_key is not None else get_api_key()
+
+    @property
+    def _auth_headers(self) -> Optional[Dict]:
+        return {"Authorization": f"Bearer {self.api_key}"} if self.api_key else None
+
+    @staticmethod
+    def _raise_for_structured_error(status_code: int, body_text: str) -> None:
+        try:
+            body = json.loads(body_text) if body_text else None
+        except Exception:
+            body = None
+        detail = body.get("detail") if isinstance(body, dict) else None
+        if isinstance(detail, dict) and detail.get("code") == "PRIVATE_SLOT_LIMIT":
+            raise PrivateSlotLimitError(detail)
+        if isinstance(detail, dict) and detail.get("code"):
+            raise BackendApiError(
+                status_code,
+                detail.get("message") or str(detail),
+                code=detail.get("code"),
+                detail=detail,
+            )
+        # Auth / ACL denials often use a plain string detail (e.g. private install).
+        if status_code in (401, 403):
+            if isinstance(detail, str) and detail.strip():
+                message = detail.strip()
+            elif isinstance(detail, dict):
+                message = str(detail.get("message") or detail)
+            else:
+                message = (body_text or f"HTTP {status_code}")[:300]
+            raise BackendApiError(status_code, message, detail=detail)
+
+    def _request(self, method: str, path: str, payload=None, params: Dict = None) -> Optional[Any]:
+        params = self._catalog_params(params or {})
+        try:
+            with httpx.Client() as client:
+                response = client.request(
+                    method,
+                    self.backend_url + path,
+                    json=payload,
+                    params=params,
+                    headers=self._auth_headers,
+                    timeout=400,
+                )
+            if response.status_code in (200, 202):
+                return response.json() if response.content else {}
+            self._raise_for_structured_error(response.status_code, response.text)
+            print(f"Request to {path} failed with status {response.status_code}: {response.text[:300]}")
+            return None
+        except (PrivateSlotLimitError, BackendApiError):
+            raise
+        except Exception as e:
+            print(f"Request to {path} failed: {e}")
+            return None
+
+    @staticmethod
+    def _catalog_params(params: Dict) -> Dict:
+        """Flatten list params for FastAPI repeated query keys."""
+        flat: Dict[str, Any] = {}
+        for key, value in params.items():
+            if value is None:
+                continue
+            if isinstance(value, list):
+                if value:
+                    flat[key] = value
+            else:
+                flat[key] = value
+        return flat
+
+    def _post(self, path: str, payload=None, params: Dict = None) -> Optional[Any]:
+        return self._request("POST", path, payload=payload, params=params)
+
+    def _get(self, path: str, params: Dict = None) -> Optional[Any]:
+        return self._request("GET", path, params=params)
+
+    @staticmethod
+    def _unwrap_list(payload: Any) -> list:
+        """Accept bare arrays or ``{ids, entities}`` query envelopes."""
+        if payload is None:
+            return []
+        if isinstance(payload, list):
+            return payload
+        if isinstance(payload, dict):
+            if "entities" in payload:
+                return payload.get("entities") or []
+            if "data" in payload and isinstance(payload["data"], list):
+                return payload["data"]
+        return []

socaity_cli/prompts.py

@@ -0,0 +1,17 @@
+"""Interactive CLI prompts shared across socaity and apipod commands."""
+import sys
+
+_VALID_YES_NO = {"yes": True, "y": True, "ye": True, "no": False, "n": False}
+
+
+def input_yes_no(question: str, default: bool = True) -> bool:
+    """Prompt for yes/no. Empty input returns ``default``."""
+    prompt = " [Y/n] " if default else " [y/N] "
+    while True:
+        sys.stdout.write(question + prompt)
+        choice = input().lower()
+        if choice == "":
+            return default
+        if choice in _VALID_YES_NO:
+            return _VALID_YES_NO[choice]
+        sys.stdout.write("Please respond with 'yes' or 'no' (or 'y'/'n').\n")