socaity-cli 0.1.1__py3-none-any.whl

socaity_cli/__init__.py

@@ -0,0 +1,30 @@
+"""Socaity platform CLI.
+
+Lightweight bundle of all Socaity CLI commands and the backend HTTP client
+(httpx + socaity-schemas only). Heavy features delegate to the optional
+``socaity`` (SDK installs) and ``apipod`` (deployment tooling) packages via
+the ``requires`` decorator.
+"""
+from socaity_cli.backend_client import SocaityBackendClient
+from socaity_cli.credentials import (
+    Credentials,
+    clear_credentials,
+    get_api_key,
+    load_credentials,
+    require_credentials,
+    save_credentials,
+)
+from socaity_cli.requires import requires
+from socaity_cli.prompts import input_yes_no
+
+__all__ = [
+    "SocaityBackendClient",
+    "Credentials",
+    "clear_credentials",
+    "get_api_key",
+    "load_credentials",
+    "require_credentials",
+    "save_credentials",
+    "requires",
+    "input_yes_no",
+]

socaity_cli/__main__.py

@@ -0,0 +1,4 @@
+from socaity_cli.cli import main
+
+if __name__ == "__main__":
+    main()

socaity_cli/apipod_commands.py

@@ -0,0 +1,82 @@
+"""Bridge to the APIPod CLI (requires ``pip install apipod``).
+
+Imports stay inside the functions: ``apipod`` is optional for the CLI and the
+``requires`` decorator guards each entry with a friendly install hint.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import List, Optional
+
+from socaity_cli.requires import requires
+
+
+def _with_project_dir(argv: List[str], project_dir: Optional[str]) -> List[str]:
+    if project_dir:
+        return ["-C", project_dir, *argv]
+    return argv
+
+
+@requires("apipod")
+def _run_apipod_argv(argv: List[str]) -> None:
+    import apipod.cli
+
+    previous = sys.argv
+    sys.argv = ["apipod", *argv]
+    try:
+        apipod.cli.main()
+    finally:
+        sys.argv = previous
+
+
+def run_scan(*, project_dir: Optional[str] = None) -> None:
+    _run_apipod_argv(_with_project_dir(["scan"], project_dir))
+
+
+def run_build(target_file: Optional[str], *, project_dir: Optional[str] = None) -> None:
+    argv = ["build"]
+    if target_file:
+        argv.append(target_file)
+    _run_apipod_argv(_with_project_dir(argv, project_dir))
+
+
+def run_start(
+    *,
+    entrypoint: Optional[str],
+    host: Optional[str],
+    port: Optional[int],
+    project_dir: Optional[str] = None,
+) -> None:
+    argv = ["start"]
+    if entrypoint:
+        argv.append(entrypoint)
+    if host:
+        argv.extend(["--host", host])
+    if port is not None:
+        argv.extend(["--port", str(port)])
+    _run_apipod_argv(_with_project_dir(argv, project_dir))
+
+
+def run_deploy(
+    *,
+    target: Optional[str] = None,
+    project_dir: Optional[str] = None,
+    resume: Optional[str] = None,
+    skip_build: bool = False,
+    push_only: bool = False,
+    yes: bool = False,
+) -> None:
+    """Wrap ``apipod deploy`` (analyze, build, push, provision)."""
+    argv = ["deploy"]
+    if target:
+        argv.append(target)
+    if resume:
+        argv.extend(["--resume", resume])
+    if skip_build:
+        argv.append("--skip-build")
+    if push_only:
+        argv.append("--push-only")
+    if yes:
+        argv.append("--yes")
+    _run_apipod_argv(_with_project_dir(argv, project_dir))

socaity_cli/auth.py

@@ -0,0 +1,197 @@
+"""Browser-based CLI login (device authorization flow via web UI)."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import time
+import webbrowser
+from typing import Any, Dict, Optional
+from urllib.parse import urljoin
+
+import httpx
+
+from socaity_cli.credentials import (
+    Credentials,
+    DEFAULT_BACKEND_URL,
+    DEFAULT_FRONTEND_URL,
+    require_credentials,
+    save_credentials,
+)
+
+USER_AGENT = "socaity-cli/0.1.0"
+
+
+def _backend_base_url() -> str:
+    return os.environ.get("SOCAITY_BACKEND_URL", DEFAULT_BACKEND_URL).rstrip("/")
+
+
+def _frontend_base_url(frontend_url: Optional[str] = None) -> str:
+    if frontend_url is not None:
+        value = frontend_url.strip()
+        return value.rstrip("/") if value else DEFAULT_FRONTEND_URL
+    return os.environ.get("SOCAITY_FRONTEND_URL", DEFAULT_FRONTEND_URL).rstrip("/")
+
+
+def _web_api_url(base: str) -> str:
+    return urljoin(base + "/", "v1/")
+
+
+def open_login_url(url: str) -> bool:
+    try:
+        if webbrowser.open(url):
+            return True
+    except Exception:
+        pass
+    for cmd in ("wslview", "xdg-open"):
+        exe = shutil.which(cmd)
+        if not exe:
+            continue
+        try:
+            subprocess.run(
+                [exe, url],
+                check=False,
+                timeout=8,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            return True
+        except Exception:
+            continue
+    return False
+
+
+def start_cli_login(
+    *,
+    backend_url: Optional[str] = None,
+    frontend_url: Optional[str] = None,
+    expires_in_seconds: int = 600,
+) -> Dict[str, Any]:
+    base = (backend_url or _backend_base_url()).rstrip("/")
+    payload: Dict[str, Any] = {"expires_in_seconds": expires_in_seconds}
+    payload["frontend_base_url"] = _frontend_base_url(frontend_url)
+    with httpx.Client(timeout=20.0) as client:
+        response = client.post(
+            _web_api_url(base) + "cli-auth/start",
+            json=payload,
+            headers={"User-Agent": USER_AGENT},
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+def poll_cli_login(
+    *,
+    request_id: str,
+    poll_code: str,
+    backend_url: Optional[str] = None,
+) -> Dict[str, Any]:
+    base = (backend_url or _backend_base_url()).rstrip("/")
+    with httpx.Client(timeout=20.0) as client:
+        response = client.post(
+            _web_api_url(base) + "cli-auth/poll",
+            json={"request_id": request_id, "poll_code": poll_code},
+            headers={"User-Agent": USER_AGENT},
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+def fetch_profile(*, api_key: str, backend_url: str) -> Dict[str, Any]:
+    base = backend_url.rstrip("/")
+    with httpx.Client(timeout=20.0) as client:
+        response = client.get(
+            _web_api_url(base) + "profile/profile",
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "User-Agent": USER_AGENT,
+            },
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+def run_login(
+    *,
+    no_browser: bool = False,
+    timeout: int = 300,
+    backend_url: Optional[str] = None,
+    frontend_url: Optional[str] = None,
+) -> Credentials:
+    base = (backend_url or _backend_base_url()).rstrip("/")
+
+    print("Login to Socaity")
+    session = start_cli_login(
+        backend_url=base,
+        frontend_url=frontend_url,
+    )
+    verification_uri = session["verification_uri"]
+    request_id = session["request_id"]
+    poll_code = session["poll_code"]
+    interval = max(int(session.get("interval_seconds", 2)), 1)
+
+    print(f"Open this URL to authenticate:\n{verification_uri}")
+
+    if not no_browser:
+        if open_login_url(verification_uri):
+            print("Browser opened for login.")
+        else:
+            print("Could not open a browser automatically. Open the URL manually.")
+
+    print("Waiting for login confirmation...")
+    deadline = time.time() + max(timeout, 10)
+
+    while time.time() < deadline:
+        poll_response = poll_cli_login(
+            request_id=request_id,
+            poll_code=poll_code,
+            backend_url=base,
+        )
+        status = poll_response.get("status")
+
+        if status == "pending":
+            time.sleep(interval)
+            continue
+        if status == "expired":
+            print("Login request expired. Run: socaity login")
+            raise SystemExit(1)
+        if status == "approved":
+            api_key = (poll_response.get("api_key") or "").strip()
+            if not api_key:
+                print("Login failed: missing API key in response.")
+                raise SystemExit(1)
+            creds = Credentials(
+                api_key=api_key,
+                user_id=poll_response.get("user_id"),
+                user_email=poll_response.get("user_email"),
+                backend_url=base,
+            )
+            path = save_credentials(creds)
+            email = creds.user_email or "user"
+            print(f"Logged in as {email}")
+            print(f"Credentials saved to {path}")
+            return creds
+
+        print(f"Login failed: unexpected status '{status}'")
+        raise SystemExit(1)
+
+    print("Login timed out. Run: socaity login")
+    raise SystemExit(1)
+
+
+def run_whoami() -> None:
+    creds = require_credentials()
+    email = creds.user_email
+    user_id = creds.user_id
+    if not email or not user_id:
+        try:
+            profile = fetch_profile(api_key=creds.api_key, backend_url=creds.backend_url)
+            email = email or profile.get("email") or profile.get("user_email")
+            user_id = user_id or profile.get("id") or profile.get("user_id")
+        except Exception as exc:
+            print(f"Could not fetch profile: {exc}")
+            raise SystemExit(1) from exc
+    print(f"user_id: {user_id}")
+    print(f"email: {email}")
+    print(f"backend: {creds.backend_url}")

socaity_cli/backend_client.py

@@ -0,0 +1,23 @@
+"""Composed platform backend client (catalog, jobs, projects, analytics, files, sdk, deployment)."""
+from socaity_cli.clients.analytics import AnalyticsClient
+from socaity_cli.clients.catalog import CatalogClient
+from socaity_cli.clients.deployment import DeploymentClient
+from socaity_cli.clients.files import FilesClient
+from socaity_cli.clients.jobs import JobsClient
+from socaity_cli.clients.projects import ProjectsClient
+from socaity_cli.clients.sdk_install import SdkInstallClient
+from socaity_cli.http import BackendHttp
+
+
+class SocaityBackendClient(
+    BackendHttp,
+    CatalogClient,
+    JobsClient,
+    ProjectsClient,
+    AnalyticsClient,
+    FilesClient,
+    SdkInstallClient,
+    DeploymentClient,
+):
+    """Facade over domain mixins. Prefer importing a domain client when you only need one surface."""
+    pass

socaity_cli/cli.py

@@ -0,0 +1,352 @@
+"""Unified Socaity CLI: auth, catalog, SDK installs, and APIPod deployment tooling."""
+
+from __future__ import annotations
+
+import argparse
+
+from socaity_cli.apipod_commands import run_build, run_deploy, run_scan, run_start
+from socaity_cli.auth import run_login, run_whoami
+from socaity_cli.backend_client import SocaityBackendClient
+from socaity_cli.credentials import clear_credentials, require_credentials
+from socaity_cli.sdk_commands import run_install, run_update
+
+
+def _run_list(entity: str, category: str | None, family: str | None, limit: int) -> None:
+    client = SocaityBackendClient()
+    if entity == "services":
+        services = client.list_services(category=category, limit=limit)
+        if not services:
+            print("No services found.")
+            return
+        for service in services:
+            name = service.display_name or service.name or service.id
+            official = " [official]" if service.is_official else ""
+            desc = f" - {service.short_desc}" if service.short_desc else ""
+            print(f"{name}{official}{desc}")
+    else:
+        models = client.list_models(family=family, limit=limit)
+        if not models:
+            print("No models found.")
+            return
+        for model in models:
+            name = model.display_name or model.name
+            family_info = f" ({model.family})" if model.family else ""
+            print(f"{name}{family_info}")
+
+
+def _split_csv(value: str | None) -> list[str]:
+    return [part.strip() for part in (value or "").split(",") if part.strip()]
+
+
+def _run_jobs(
+    job_id: str | None,
+    expand: str | None,
+    status: str | None,
+    visibility: str,
+    limit: int,
+    q: str | None = None,
+) -> None:
+    client = SocaityBackendClient()
+    expand_list = _split_csv(expand)
+
+    def _print_job(job) -> None:
+        cost = ""
+        if job.billing and job.billing.cost_amount is not None:
+            cost = f"  {job.billing.cost_amount:.4f} {job.billing.cost_currency or 'EUR'}"
+        name = f"  '{job.data.display_name}'" if job.data and job.data.display_name else ""
+        print(f"{job.id}  [{job.status}]  {job.endpoint or '?'}  {job.created_at or ''}{cost}{name}")
+
+    if job_id:
+        job = client.get_job(job_id, expand=expand_list)
+        if not job:
+            print(f"Job '{job_id}' not found.")
+            return
+        print(job.model_dump_json(indent=2, exclude_none=True))
+        return
+
+    filters = [f"status:eq:{status}"] if status else None
+    jobs = client.query_jobs(
+        q=q, filters=filters, expand=expand_list, visibility=visibility, limit=limit,
+    )
+    if not jobs:
+        print("No jobs found.")
+        return
+    for job in jobs:
+        _print_job(job)
+
+
+def _run_projects(project_id: str | None, expand: str | None, limit: int) -> None:
+    client = SocaityBackendClient()
+    expand_list = _split_csv(expand)
+
+    if project_id:
+        project = client.get_project(project_id, expand=expand_list)
+        if not project:
+            print(f"Project '{project_id}' not found.")
+            return
+        print(project.model_dump_json(indent=2, exclude_none=True))
+        return
+
+    projects = client.query_projects(expand=expand_list, limit=limit)
+    if not projects:
+        print("No projects found.")
+        return
+    for project in projects:
+        name = project.display_name or project.id
+        print(f"{project.id}  {name}  ({project.n_jobs or 0} jobs, {project.n_files or 0} files)")
+
+
+def _run_search(query: str, collections: str | None, limit: int) -> None:
+    client = SocaityBackendClient()
+    targets = [part.strip() for part in (collections or "services,models").split(",") if part.strip()]
+    found = False
+    for collection in targets:
+        hits = client.search(query, collection=collection, limit=limit)
+        if not hits:
+            continue
+        found = True
+        for item in hits:
+            if collection == "jobs":
+                name = getattr(getattr(item, "data", None), "display_name", None) or item.id
+                status = f" [{item.status}]" if getattr(item, "status", None) else ""
+                print(f"[jobs] {name}{status}")
+                continue
+            name = item.display_name or item.name or item.id
+            desc = getattr(item, "short_desc", None) or getattr(item, "description", None) or ""
+            print(f"[{collection}] {name}" + (f" - {desc[:80]}" if desc else ""))
+    if not found:
+        print("No results.")
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="socaity",
+        description="Socaity platform CLI: authentication, catalog, SDK, and APIPod deployment",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  socaity login
+  socaity install black-forest-labs/flux-schnell
+  socaity update
+  socaity list services
+  socaity search "flux schnell"
+  socaity search "lighthouse" --collections jobs
+  socaity jobs --q lighthouse --expand data
+  socaity projects --expand jobs
+  socaity scan
+  socaity build main.py
+  socaity start --port 8123
+  socaity deploy serverless-runpod
+  socaity -C simple_test_service deploy serverless-runpod --yes
+        """,
+    )
+    parser.add_argument(
+        "-i", "--install",
+        metavar="SERVICE",
+        help="Install an AI service (requires login)",
+    )
+    parser.add_argument(
+        "-C",
+        "--project-dir",
+        default=None,
+        metavar="DIR",
+        help="Service project directory for apipod commands (scan/build/start/deploy).",
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    login_parser = subparsers.add_parser("login", help="Authenticate via browser and save credentials")
+    login_parser.add_argument("--no-browser", action="store_true", help="Do not open a browser automatically")
+    login_parser.add_argument("--timeout", type=int, default=300, help="Seconds to wait for browser login")
+    login_parser.add_argument(
+        "--backend-url",
+        default=None,
+        help="API base URL (default: SOCAITY_BACKEND_URL or https://webapi.socaity.ai)",
+    )
+    login_parser.add_argument(
+        "--frontend-url",
+        default=None,
+        help="Web UI base URL for sign-in (default: SOCAITY_FRONTEND_URL or https://socaity.ai)",
+    )
+
+    subparsers.add_parser("logout", help="Remove stored credentials")
+    subparsers.add_parser("whoami", help="Show logged-in user")
+
+    install_parser = subparsers.add_parser("install", help="Install an AI service (requires socaity)")
+    install_parser.add_argument("service_name", help='Service name, ID, or "all"')
+
+    subparsers.add_parser("update", help="Sync installed services with the platform (requires socaity)")
+
+    list_parser = subparsers.add_parser("list", help="List catalog entries")
+    list_parser.add_argument("entity", choices=("services", "models"), help="What to list")
+    list_parser.add_argument("--category", default=None, help="Filter services by category id")
+    list_parser.add_argument("--family", default=None, help="Filter models by family")
+    list_parser.add_argument("--limit", type=int, default=50)
+
+    search_parser = subparsers.add_parser("search", help="Fuzzy-search services, models, or jobs")
+    search_parser.add_argument("query", help="Search text (typo-tolerant)")
+    search_parser.add_argument("--collections", default=None, help="Comma-separated: services,models,jobs")
+    search_parser.add_argument("--limit", type=int, default=20)
+
+    jobs_parser = subparsers.add_parser("jobs", help="List/search your jobs or inspect one (requires login)")
+    jobs_parser.add_argument("job_id", nargs="?", default=None, help="Job id for a detailed view")
+    jobs_parser.add_argument("--q", default=None, help="Fuzzy search over job prompts / display names")
+    jobs_parser.add_argument("--expand", default=None, help="Comma-separated: data,files,billing,social")
+    jobs_parser.add_argument("--status", default=None, help="Filter by status (e.g. FINISHED)")
+    jobs_parser.add_argument(
+        "--visibility",
+        choices=("user", "public", "user_visible"),
+        default="user_visible",
+        help="user: own jobs. public: published. user_visible: own + public (default).",
+    )
+    jobs_parser.add_argument("--limit", type=int, default=25)
+
+    projects_parser = subparsers.add_parser("projects", help="List your projects or inspect one (requires login)")
+    projects_parser.add_argument("project_id", nargs="?", default=None, help="Project id for a detailed view")
+    projects_parser.add_argument("--expand", default=None, help="Comma-separated: jobs (nested: jobs.data, ...)")
+    projects_parser.add_argument("--limit", type=int, default=25)
+
+    subparsers.add_parser("scan", help="Scan project and generate apipod.json (requires apipod)")
+
+    build_parser = subparsers.add_parser("build", help="Build deployment container (requires apipod)")
+    build_parser.add_argument("file", nargs="?", default=None, help="Entry Python file (e.g. main.py)")
+
+    start_parser = subparsers.add_parser("start", help="Start APIPod service locally (requires apipod)")
+    start_parser.add_argument("entrypoint", nargs="?", default=None, help="Service entrypoint file")
+    start_parser.add_argument("--host", default=None, help="Host to bind (default: 0.0.0.0)")
+    start_parser.add_argument("--port", type=int, default=None, help="Port to bind (default: 8000)")
+
+    deploy_parser = subparsers.add_parser(
+        "deploy",
+        help="Deploy to Socaity via APIPod (requires apipod)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  socaity deploy\n"
+            "  socaity deploy serverless-runpod\n"
+            "  socaity -C simple_test_service deploy serverless-runpod --yes\n"
+            "  socaity deploy --skip-build\n"
+            "  socaity deploy --resume DEPLOYMENT_ID"
+        ),
+    )
+    deploy_parser.add_argument(
+        "target",
+        nargs="?",
+        default="serverless",
+        metavar="TARGET",
+        help="Deployment target '{compute}-{provider}' (default: serverless).",
+    )
+    deploy_parser.add_argument(
+        "--resume",
+        default=None,
+        metavar="DEPLOYMENT_ID",
+        help="Skip analyze/draft and push into an existing deployment attempt.",
+    )
+    deploy_parser.add_argument(
+        "--skip-build",
+        action="store_true",
+        help="Do not rebuild the container; push the existing local image.",
+    )
+    deploy_parser.add_argument(
+        "--push-only",
+        action="store_true",
+        help="With --resume: only push and poll, never build or create drafts.",
+    )
+    deploy_parser.add_argument(
+        "-y", "--yes",
+        action="store_true",
+        help="Non-interactive: skip confirmations (CI / automated runs).",
+    )
+
+    args = parser.parse_args(argv)
+
+    if args.install:
+        require_credentials()
+        run_install(args.install)
+        return
+
+    if args.command == "login":
+        run_login(
+            no_browser=args.no_browser,
+            timeout=args.timeout,
+            backend_url=args.backend_url,
+            frontend_url=args.frontend_url,
+        )
+        return
+
+    if args.command == "logout":
+        if clear_credentials():
+            print("Logged out. Credentials removed.")
+        else:
+            print("Not logged in.")
+        return
+
+    if args.command == "whoami":
+        run_whoami()
+        return
+
+    if args.command == "install":
+        require_credentials()
+        run_install(args.service_name)
+        return
+
+    if args.command == "update":
+        require_credentials()
+        run_update()
+        return
+
+    if args.command == "list":
+        _run_list(args.entity, args.category, args.family, args.limit)
+        return
+
+    if args.command == "search":
+        targets = [part.strip() for part in (args.collections or "services,models").split(",") if part.strip()]
+        if "jobs" in targets:
+            require_credentials()
+        _run_search(args.query, args.collections, args.limit)
+        return
+
+    if args.command == "jobs":
+        if args.visibility != "public":
+            require_credentials()
+        _run_jobs(args.job_id, args.expand, args.status, args.visibility, args.limit, q=args.q)
+        return
+
+    if args.command == "projects":
+        require_credentials()
+        _run_projects(args.project_id, args.expand, args.limit)
+        return
+
+    if args.command == "scan":
+        run_scan(project_dir=args.project_dir)
+        return
+
+    if args.command == "build":
+        run_build(args.file, project_dir=args.project_dir)
+        return
+
+    if args.command == "start":
+        run_start(
+            entrypoint=args.entrypoint,
+            host=args.host,
+            port=args.port,
+            project_dir=args.project_dir,
+        )
+        return
+
+    if args.command == "deploy":
+        run_deploy(
+            target=args.target,
+            project_dir=args.project_dir,
+            resume=args.resume,
+            skip_build=args.skip_build,
+            push_only=args.push_only,
+            yes=args.yes,
+        )
+        return
+
+    parser.print_help()
+
+
+if __name__ == "__main__":
+    main()