sovaria-cli 0.2.0__py3-none-any.whl

apps/cli/src/commands/iam.py

@@ -0,0 +1,436 @@
+"""Identity and access management commands."""
+
+from __future__ import annotations
+
+from urllib.parse import quote
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api, parse_json_arg
+from apps.cli.src.utils.display import print_json
+
+app = typer.Typer(help="Organisations, members, and project listings")
+
+
+@app.command("orgs")
+def list_orgs(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List organisations visible to the authenticated user."""
+    try:
+        result = call_api(method="GET", path="/api/v1/org", profile=profile)
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("org")
+def get_org(
+    org_id: str = typer.Argument(..., help="Organisation node ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch one organisation by ID."""
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/org/{quote(org_id, safe='')}",
+            profile=profile,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("projects")
+def list_projects(
+    org_id: str = typer.Argument(..., help="Parent organisation ID"),
+    relation: str = typer.Option("OWNS", "--relation", help="Edge relation filter"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List child projects under an organisation."""
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/org/{quote(org_id, safe='')}/children",
+            profile=profile,
+            params={"relation": relation},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("members")
+def list_members(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List organisation members."""
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/org/{quote(org_id, safe='')}/children",
+            profile=profile,
+            params={"relation": "MEMBER_OF"},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("member-add")
+def member_add(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    user_id: str = typer.Argument(..., help="User node ID"),
+    role: str = typer.Option("MEMBER", "--role"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Add a member to an organisation."""
+    try:
+        result = call_api(
+            method="POST",
+            path=f"/api/v1/org/{quote(org_id, safe='')}/member",
+            profile=profile,
+            body={"user_id": user_id, "role": role},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("settings-get")
+def settings_get(
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Fetch project settings for the linked scope."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/project-settings",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("settings-set")
+def settings_set(
+    settings_json: str = typer.Argument(..., help="JSON object of project settings"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Update project settings."""
+    body = parse_json_arg(settings_json, label="settings")
+    if body is None or not isinstance(body, dict):
+        raise typer.BadParameter("settings must be a JSON object")
+    try:
+        result = call_api(
+            method="PUT",
+            path="/api/v1/project-settings",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+            body=body,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("org-update")
+def org_update(
+    org_id: str = typer.Argument(..., help="Organisation node ID"),
+    name: str | None = typer.Option(None, "--name"),
+    settings_json: str | None = typer.Option(None, "--settings", help="JSON settings object"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Update organisation name and/or admin settings."""
+    body: dict[str, object] = {}
+    if name is not None:
+        body["name"] = name
+    if settings_json is not None:
+        settings = parse_json_arg(settings_json, label="settings")
+        if settings is None or not isinstance(settings, dict):
+            raise typer.BadParameter("--settings must be a JSON object")
+        body["settings"] = settings
+    if not body:
+        raise typer.BadParameter("Provide --name and/or --settings")
+    try:
+        result = call_api(
+            method="PUT",
+            path=f"/api/v1/org/{quote(org_id, safe='')}",
+            profile=profile,
+            body=body,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("org-delete")
+def org_delete(
+    org_id: str = typer.Argument(..., help="Organisation node ID"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Delete an organisation (async teardown)."""
+    if not yes and not typer.confirm(f"Delete organisation '{org_id}'?"):
+        raise typer.Exit(0)
+    try:
+        result = call_api(
+            method="DELETE",
+            path=f"/api/v1/org/{quote(org_id, safe='')}",
+            profile=profile,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("org-set-plan")
+def org_set_plan(
+    org_id: str = typer.Argument(..., help="Organisation node ID"),
+    plan: str = typer.Option(..., "--plan", help="free | pro | ultra | team | enterprise"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Set an organisation billing plan."""
+    try:
+        result = call_api(
+            method="PUT",
+            path=f"/api/v1/org/{quote(org_id, safe='')}/plan",
+            profile=profile,
+            body={"plan": plan},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("member-remove")
+def member_remove(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    user_id: str = typer.Argument(..., help="User node ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Remove a member from an organisation."""
+    try:
+        result = call_api(
+            method="DELETE",
+            path=f"/api/v1/org/{quote(org_id, safe='')}/member/{quote(user_id, safe='')}",
+            profile=profile,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("member-update")
+def member_update(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    user_id: str = typer.Argument(..., help="User node ID"),
+    role: str = typer.Option(..., "--role"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Update a member's organisation role."""
+    try:
+        result = call_api(
+            method="PUT",
+            path=f"/api/v1/org/{quote(org_id, safe='')}/member/{quote(user_id, safe='')}",
+            profile=profile,
+            body={"role": role},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("invite-create")
+def invite_create(
+    org_id: str = typer.Argument(..., help="Organisation ID"),
+    email: str = typer.Option(..., "--email"),
+    role: str = typer.Option(..., "--role"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Create or refresh an organisation invite."""
+    try:
+        result = call_api(
+            method="POST",
+            path=f"/api/v1/org/{quote(org_id, safe='')}/invites",
+            profile=profile,
+            body={"email": email, "role": role},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("invite-accept")
+def invite_accept(
+    token: str = typer.Argument(..., help="Invite token"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Accept an organisation invite."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/org/invites/accept",
+            profile=profile,
+            body={"token": token},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("edge-create")
+def edge_create(
+    source_id: str = typer.Option(..., "--source"),
+    target_id: str = typer.Option(..., "--target"),
+    relation_type: str = typer.Option(..., "--relation", help="OWNS | MEMBER_OF | HAS_ENV"),
+    role: str | None = typer.Option(None, "--role"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Create a directed edge in the identity graph."""
+    body: dict[str, object] = {
+        "source_id": source_id,
+        "target_id": target_id,
+        "relation_type": relation_type,
+    }
+    if role is not None:
+        body["role"] = role
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/edge",
+            profile=profile,
+            body=body,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+roles_matrix_app = typer.Typer(help="Project role permission matrix")
+app.add_typer(roles_matrix_app, name="roles-matrix")
+
+
+@roles_matrix_app.command("get")
+def roles_matrix_get(
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Fetch the project role permission matrix."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/roles/matrix",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@roles_matrix_app.command("set")
+def roles_matrix_set(
+    matrix_json: str = typer.Argument(..., help="JSON role matrix object"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Replace the project role permission matrix."""
+    matrix = parse_json_arg(matrix_json, label="matrix")
+    if matrix is None or not isinstance(matrix, dict):
+        raise typer.BadParameter("matrix must be a JSON object")
+    try:
+        result = call_api(
+            method="PUT",
+            path="/api/v1/roles/matrix",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+            body={"matrix": matrix},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("roles-catalog")
+def roles_catalog(
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Fetch the project roles catalog."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/roles/catalog",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("project-ref")
+def project_ref(
+    project_id: str = typer.Argument(..., help="Project node ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch the public project ref slug."""
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/org/{quote(project_id, safe='')}/ref",
+            profile=profile,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)

apps/cli/src/commands/init_cmd.py

@@ -0,0 +1,177 @@
+"""Interactive project bootstrap wizard (`sov init`)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from sovaria.project import DEFAULT_CONFIG_FILENAME, write_project_config_template
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api
+from apps.cli.src.utils.auth_store import load_tokens
+from apps.cli.src.utils.config import get_api_url, set_scope
+from apps.cli.src.utils.display import print_banner, print_error, print_success, print_warning
+from apps.cli.src.utils.project_context import link_project_to_profile
+
+app = typer.Typer(help="Interactive Sovaria project bootstrap", invoke_without_command=True)
+
+
+def _pick_org(profile: str | None) -> str:
+    orgs = call_api(method="GET", path="/api/v1/org", profile=profile)
+    if not isinstance(orgs, list) or not orgs:
+        raise CLIRequestError("No organisations found. Create one in the console first.")
+
+    typer.echo("\nOrganisations:")
+    for index, org in enumerate(orgs, start=1):
+        name = org.get("name") or org.get("label") or org.get("node_id") or "?"
+        typer.echo(f"  {index}. {name}  ({org.get('node_id', '?')})")
+
+    if len(orgs) == 1:
+        chosen = orgs[0]
+        typer.echo(f"\nUsing sole organisation: {chosen.get('name') or chosen.get('node_id')}")
+    else:
+        selection = typer.prompt("Select organisation number", type=int)
+        if selection < 1 or selection > len(orgs):
+            raise CLIRequestError("Invalid organisation selection")
+        chosen = orgs[selection - 1]
+
+    org_id = str(chosen.get("node_id") or chosen.get("id") or "").strip()
+    if not org_id:
+        raise CLIRequestError("Selected organisation is missing node_id")
+    return org_id
+
+
+def _pick_project(org_id: str, profile: str | None) -> str:
+    from urllib.parse import quote
+
+    projects = call_api(
+        method="GET",
+        path=f"/api/v1/org/{quote(org_id, safe='')}/children",
+        profile=profile,
+        params={"relation": "OWNS"},
+    )
+    if not isinstance(projects, list) or not projects:
+        raise CLIRequestError(
+            "No projects under this organisation. Create one in the console or run `sov org create`."
+        )
+
+    typer.echo("\nProjects:")
+    for index, project in enumerate(projects, start=1):
+        name = project.get("name") or project.get("label") or project.get("node_id") or "?"
+        typer.echo(f"  {index}. {name}  ({project.get('node_id', '?')})")
+
+    if len(projects) == 1:
+        chosen = projects[0]
+        typer.echo(f"\nUsing sole project: {chosen.get('name') or chosen.get('node_id')}")
+    else:
+        selection = typer.prompt("Select project number", type=int)
+        if selection < 1 or selection > len(projects):
+            raise CLIRequestError("Invalid project selection")
+        chosen = projects[selection - 1]
+
+    project_id = str(chosen.get("node_id") or chosen.get("id") or "").strip()
+    if not project_id:
+        raise CLIRequestError("Selected project is missing node_id")
+    return project_id
+
+
+@app.callback()
+def init_wizard(
+    name: str = typer.Option("sovaria-app", "--name", "-n", help="Project name for config"),
+    directory: Path = typer.Option(Path("."), "--dir", help="Directory to write config into"),
+    link: bool = typer.Option(True, "--link/--no-link", help="Persist scope to profile + config"),
+    ensure_keys: bool = typer.Option(
+        False,
+        "--ensure-keys",
+        help="Bootstrap default anon/service_role API keys after linking",
+    ),
+    profile: str | None = typer.Option(None, "--profile"),
+    force: bool = typer.Option(False, "--force", help="Overwrite existing sovaria.config.json"),
+) -> None:
+    """
+    Supabase-style interactive setup: login check → pick org/project → write sovaria.config.json.
+
+    After init, SDK and CLI commands auto-resolve scope from the local config file.
+    """
+    print_banner("Sovaria Init", "Link your terminal to a Sovaria project")
+
+    if not load_tokens(profile=profile):
+        print_error("Not logged in.")
+        typer.echo("Run: sov login")
+        raise typer.Exit(1)
+
+    config_path = (directory.resolve() / DEFAULT_CONFIG_FILENAME)
+    if config_path.exists() and not force:
+        print_warning(f"{config_path} already exists. Use --force to overwrite.")
+        if not typer.confirm("Continue and update scope on existing config?", default=True):
+            raise typer.Exit(0)
+    else:
+        try:
+            write_project_config_template(config_path, name=name, overwrite=force)
+            print_success(f"Created {config_path}")
+        except Exception as exc:
+            print_error(str(exc))
+            raise typer.Exit(1) from exc
+
+    try:
+        org_id = _pick_org(profile)
+        project_id = _pick_project(org_id, profile)
+    except CLIRequestError as exc:
+        print_error(str(exc))
+        raise typer.Exit(1) from exc
+
+    env_id = typer.prompt("Environment ID (optional, press Enter to skip)", default="").strip()
+
+    if link:
+        try:
+            path = link_project_to_profile(
+                org_id=org_id,
+                project_id=project_id,
+                env_id=env_id or None,
+                profile=profile,
+                config_path=config_path,
+            )
+        except (FileNotFoundError, ValueError) as exc:
+            print_error(str(exc))
+            raise typer.Exit(1) from exc
+        print_success(f"Linked scope in {path}")
+
+    # Sync gateway URL from active profile into config when missing
+    try:
+        import json
+
+        raw = json.loads(config_path.read_text())
+        gateway = raw.setdefault("gateway", {})
+        if isinstance(gateway, dict) and not str(gateway.get("url") or "").strip():
+            gateway["url"] = get_api_url(profile)
+            config_path.write_text(json.dumps(raw, indent=2, sort_keys=True) + "\n")
+    except Exception:
+        pass
+
+    set_scope(org_id=org_id, project_id=project_id, env_id=env_id or None, profile=profile)
+
+    if ensure_keys:
+        try:
+            keys = call_api(
+                method="POST",
+                path="/api/v1/apikeys/ensure-defaults",
+                profile=profile,
+                org_id=org_id,
+                project_id=project_id,
+                env_id=env_id or None,
+                require_scope=True,
+                body={},
+            )
+            print_success("Default API keys ensured.")
+            typer.echo(keys)
+        except CLIRequestError as exc:
+            print_warning(f"Could not ensure default keys: {exc}")
+
+    typer.echo("")
+    print_success("Project ready.")
+    typer.echo("Next steps:")
+    typer.echo("  sov shell          # interactive REPL")
+    typer.echo("  sov data sql 'SELECT 1'")
+    typer.echo("  sov sim discover")
+    typer.echo("  sov project status")