sovaria-cli 0.3.0__tar.gz → 0.5.0__tar.gz

{sovaria_cli-0.3.0 → sovaria_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sovaria-cli
-Version: 0.3.0
+Version: 0.5.0
 Summary: Sovaria BaaS command-line interface (sov)
 Project-URL: Homepage, https://sovaria.in
 Project-URL: Documentation, https://docs.sovaria.in/cli
@@ -12,7 +12,7 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: keyring>=25.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.7.0
-Requires-Dist: sovaria-sdk==0.5.0
+Requires-Dist: sovaria-sdk==0.7.0
 Requires-Dist: tomli-w>=1.2.0
 Requires-Dist: typer>=0.17.4
 Provides-Extra: dev
@@ -22,7 +22,7 @@ Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: ruff>=0.9; extra == 'dev'
 Requires-Dist: twine>=6.0; extra == 'dev'
 Provides-Extra: mcp
-Requires-Dist: sovaria-sdk[mcp]==0.5.0; extra == 'mcp'
+Requires-Dist: sovaria-sdk[mcp]==0.7.0; extra == 'mcp'
 Description-Content-Type: text/markdown
 
 # Sovaria CLI
@@ -122,7 +122,9 @@ sov realtime ws-url my-channel --org <org_id> --project <project_id>
 - `sov fn ...` Forge function deploy/status/invoke
 - `sov project ...` project config template + scaffold creation
 - `sov api call ...` raw gateway API request
-- `sov branches list|create|get|update|use|delete` environments as branches (`create x --from staging`, `use x`)
+- `sov branches list|create|get|update|use|delete` environments as branches (`create x --from staging --data sample`, `use x`)
+- `sov branches diff|deploy|reset|restore|revert|protect|expire`: schema diff with production, deploy (checked first), reset from the parent,
+  point-in-time restore of a branch's database, revert a branch to a commit (`--include-schema`, `--include-database`), protection and end dates
 - `sov gen types typescript|python|dart|swift|kotlin -o <file>` row models from the live schema
 - `sov storage cp [-r] <src> <dst>` copy between local paths and `ss://bucket/path` (or between buckets)
 - `sov collections delete <path> [-r]` delete a collection or document (and its subcollections with `-r`)

{sovaria_cli-0.3.0 → sovaria_cli-0.5.0}/apps/cli/README.md

@@ -95,7 +95,9 @@ sov realtime ws-url my-channel --org <org_id> --project <project_id>
 - `sov fn ...` Forge function deploy/status/invoke
 - `sov project ...` project config template + scaffold creation
 - `sov api call ...` raw gateway API request
-- `sov branches list|create|get|update|use|delete` environments as branches (`create x --from staging`, `use x`)
+- `sov branches list|create|get|update|use|delete` environments as branches (`create x --from staging --data sample`, `use x`)
+- `sov branches diff|deploy|reset|restore|revert|protect|expire`: schema diff with production, deploy (checked first), reset from the parent,
+  point-in-time restore of a branch's database, revert a branch to a commit (`--include-schema`, `--include-database`), protection and end dates
 - `sov gen types typescript|python|dart|swift|kotlin -o <file>` row models from the live schema
 - `sov storage cp [-r] <src> <dst>` copy between local paths and `ss://bucket/path` (or between buckets)
 - `sov collections delete <path> [-r]` delete a collection or document (and its subcollections with `-r`)

{sovaria_cli-0.3.0 → sovaria_cli-0.5.0}/apps/cli/src/__init__.py

@@ -1,3 +1,3 @@
 """Sovaria CLI — sov command."""
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"

{sovaria_cli-0.3.0 → sovaria_cli-0.5.0}/apps/cli/src/commands/alerts.py

@@ -4,6 +4,7 @@ database connections cross a threshold (Observability › Alerts).
     sov alerts list
     sov alerts create --metric latency_p95_ms --threshold 800 [--window 15] [--target "GET /rest/v1/orders"]
                       [--no-email] [--webhook https://hooks.example.com/sovaria]
+    sov alerts create --metric crash_new_issues --threshold 0 --window 15      (any new crash issue)
     sov alerts pause|resume <rule-id>
     sov alerts test <rule-id>
     sov alerts delete <rule-id>
@@ -22,7 +23,9 @@ from apps.cli.src.utils.output_mode import wants_json
 
 app = typer.Typer(help="SLO alerts: latency, 5xx rate, function failures, DB connections → email / signed webhook")
 
-METRICS = ("latency_p95_ms", "latency_p99_ms", "error_rate", "function_failures", "db_connections")
+METRICS = ("latency_p95_ms", "latency_p99_ms", "error_rate", "function_failures", "db_connections",
+           # App crashes (Echo): a spike of events (target: an issue fingerprint or release:<version>), new or regressed issues.
+           "crash_events", "crash_new_issues", "crash_regressions")
 BASE = "/api/v1/observability/alerts"
 
 

sovaria_cli-0.5.0/apps/cli/src/commands/analytics.py

@@ -0,0 +1,225 @@
+"""`sov analytics`: product analytics from your apps (sov.analytics in the SDK).
+
+    sov analytics overview [--days 30]
+    sov analytics events [--days 30]
+    sov analytics trend <event> [--days 30]
+    sov analytics funnel view_item add_to_cart purchase [--window 24] [--days 30]
+    sov analytics retention [--start signup] [--return purchase] [--period week|day] [--periods 8]
+    sov analytics users [--q prefix]  /  sov analytics user <user_key>
+    sov analytics live [--follow]
+    sov analytics export [--since 2026-10-01] [--until …] [--format csv|ndjson] [--out file] [--names a,b]
+    sov analytics export --to-db [--table sovaria_analytics.events]   # then query events with SQL next to your tables
+    sov analytics erase <user_key> --yes
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api
+from apps.cli.src.utils.display import handle_cli_error, print_json, print_success
+from apps.cli.src.utils.output_mode import wants_json
+
+app = typer.Typer(help="Product analytics from your apps: active users, events, funnels, retention, export")
+
+_PROFILE = typer.Option(None, "--profile")
+_ORG = typer.Option(None, "--org")
+_PROJECT = typer.Option(None, "--project")
+_ENV = typer.Option(None, "--env")
+BASE = "/api/v1/analytics"
+_TABLE = re.compile(r"^[a-z_][a-z0-9_]{0,62}(\.[a-z_][a-z0-9_]{0,62})?$")
+
+
+def _call(method: str, path: str, *, profile, org_id, project_id, env_id, body=None, params=None, timeout: float = 60.0) -> Any:
+    try:
+        return call_api(method=method, path=path, profile=profile, org_id=org_id, project_id=project_id, env_id=env_id,
+                        require_scope=True, body=body, params=params, timeout=timeout)
+    except CLIRequestError as exc:
+        handle_cli_error(exc)
+
+
+@app.command("overview")
+def overview(days: int = typer.Option(30, "--days", min=1, max=1825), profile: str | None = _PROFILE, org_id: str | None = _ORG,
+             project_id: str | None = _PROJECT, env_id: str | None = _ENV) -> None:
+    """DAU / WAU / MAU, events and top events, platforms, countries, usage."""
+    data = _call("GET", f"{BASE}/overview", params={"days": str(days)}, profile=profile, org_id=org_id, project_id=project_id,
+                 env_id=env_id)
+    if wants_json():
+        print_json(data)
+        return
+    k = data.get("kpis", {})
+    print_json({"dau": k.get("dau"), "wau": k.get("wau"), "mau": k.get("mau"), "stickiness_pct": k.get("stickiness_pct"),
+                "events": k.get("events"), "top_events": data.get("top_events", [])[:10],
+                "usage": data.get("usage"), "limit": (data.get("limits") or {}).get("events_month")}, title=f"Analytics, last {days} days")
+
+
+@app.command("events")
+def events(days: int = typer.Option(30, "--days", min=1, max=1825), profile: str | None = _PROFILE, org_id: str | None = _ORG,
+           project_id: str | None = _PROJECT, env_id: str | None = _ENV) -> None:
+    """Event names with counts."""
+    data = _call("GET", f"{BASE}/events", params={"days": str(days)}, profile=profile, org_id=org_id, project_id=project_id,
+                 env_id=env_id)
+    print_json(data if wants_json() else data.get("events", []), title="Events")
+
+
+@app.command("trend")
+def trend(name: str, days: int = typer.Option(30, "--days", min=1, max=1825), profile: str | None = _PROFILE,
+          org_id: str | None = _ORG, project_id: str | None = _PROJECT, env_id: str | None = _ENV) -> None:
+    """One event per day: count and distinct users."""
+    data = _call("GET", f"{BASE}/events/{quote(name, safe='')}/trend", params={"days": str(days)}, profile=profile,
+                 org_id=org_id, project_id=project_id, env_id=env_id)
+    if wants_json():
+        print_json(data)
+        return
+    rows = [{"day": d, "count": c, "users": u} for d, c, u in zip(data["days"], data["count"], data["users"], strict=False)]
+    print_json(rows, title=f"{name} per day")
+
+
+@app.command("funnel")
+def funnel(steps: list[str] = typer.Argument(..., help="event names in order"),
+           window: int = typer.Option(24, "--window", help="hours from the first step"),
+           days: int = typer.Option(30, "--days", min=1, max=1825), profile: str | None = _PROFILE, org_id: str | None = _ORG,
+           project_id: str | None = _PROJECT, env_id: str | None = _ENV) -> None:
+    """Conversion through ordered steps."""
+    if len(steps) < 2:
+        raise typer.BadParameter("A funnel needs at least two steps")
+    data = _call("POST", f"{BASE}/funnel", body={"steps": [{"name": s} for s in steps], "window_hours": window, "days": days},
+                 profile=profile, org_id=org_id, project_id=project_id, env_id=env_id)
+    print_json(data if wants_json() else data.get("steps", []), title="Funnel")
+
+
+@app.command("retention")
+def retention(start: str | None = typer.Option(None, "--start", help="cohort event (default: first seen)"),
+              ret: str | None = typer.Option(None, "--return", help="return event (default: any activity)"),
+              period: str = typer.Option("week", "--period", help="week | day"), periods: int = typer.Option(8, "--periods"),
+              profile: str | None = _PROFILE, org_id: str | None = _ORG, project_id: str | None = _PROJECT,
+              env_id: str | None = _ENV) -> None:
+    """Retention cohorts (finished periods only)."""
+    if period not in ("week", "day"):
+        raise typer.BadParameter("--period is week or day")
+    params = {"period": period, "periods": str(periods), **({"start_event": start} if start else {}),
+              **({"return_event": ret} if ret else {})}
+    data = _call("GET", f"{BASE}/retention", params=params, profile=profile, org_id=org_id, project_id=project_id, env_id=env_id)
+    print_json(data if wants_json() else data.get("cohorts", []), title=f"Retention by {period}")
+
+
+@app.command("users")
+def users(q: str = typer.Option("", "--q"), limit: int = typer.Option(50, "--limit", min=1, max=200), profile: str | None = _PROFILE,
+          org_id: str | None = _ORG, project_id: str | None = _PROJECT, env_id: str | None = _ENV) -> None:
+    """Recently seen app users and their properties."""
+    data = _call("GET", f"{BASE}/users", params={"q": q, "limit": str(limit)}, profile=profile, org_id=org_id,
+                 project_id=project_id, env_id=env_id)
+    print_json(data if wants_json() else data.get("users", []), title="Users")
+
+
+@app.command("user")
+def user(user_key: str, limit: int = typer.Option(100, "--limit", min=1, max=500), profile: str | None = _PROFILE,
+         org_id: str | None = _ORG, project_id: str | None = _PROJECT, env_id: str | None = _ENV) -> None:
+    """One user's profile, consent and latest events."""
+    print_json(_call("GET", f"{BASE}/users/{quote(user_key, safe=':')}", params={"limit": str(limit)}, profile=profile,
+                     org_id=org_id, project_id=project_id, env_id=env_id))
+
+
+@app.command("live")
+def live(follow: bool = typer.Option(False, "--follow", "-f", help="keep printing new events"),
+         profile: str | None = _PROFILE, org_id: str | None = _ORG, project_id: str | None = _PROJECT,
+         env_id: str | None = _ENV) -> None:
+    """Newest events as they arrive (debug view)."""
+    since: str | None = None
+    while True:
+        params = {"limit": "100", **({"since": since} if since else {})}
+        data = _call("GET", f"{BASE}/live", params=params, profile=profile, org_id=org_id, project_id=project_id, env_id=env_id)
+        for e in reversed(data.get("events", [])):
+            typer.echo(json.dumps({"at": e["received_at"][11:19], "event": e["name"], "user": e["user_key"],
+                                   "platform": e.get("platform"), "props": e.get("props")}))
+        events_ = data.get("events") or []
+        if events_:
+            since = events_[0]["received_at"]
+        if not follow:
+            return
+        time.sleep(2)
+
+
+def _to_db(rows: list[dict[str, Any]], table: str, *, profile, org_id, project_id, env_id) -> int:
+    schema = table.split(".", 1)[0] if "." in table else None
+    if schema:
+        _call("POST", "/api/v1/sql/query", body={"sql": f'CREATE SCHEMA IF NOT EXISTS "{schema}"'}, profile=profile,
+              org_id=org_id, project_id=project_id, env_id=env_id)
+    quoted = ".".join(f'"{p}"' for p in table.split("."))
+    _call("POST", "/api/v1/sql/query", body={"sql": (
+        f"CREATE TABLE IF NOT EXISTS {quoted} (occurred_at timestamptz NOT NULL, received_at timestamptz NOT NULL, "
+        "name text NOT NULL, user_key text NOT NULL, user_id text, anon_id text, session_id text, platform text, "
+        "app_version text, country text, props jsonb, UNIQUE (user_key, name, occurred_at, received_at))")},
+          profile=profile, org_id=org_id, project_id=project_id, env_id=env_id)
+    done = 0
+    for i in range(0, len(rows), 500):
+        chunk = rows[i:i + 500]
+        sql = (f"INSERT INTO {quoted} SELECT * FROM jsonb_to_recordset($1::jsonb) AS x(occurred_at timestamptz, "
+               "received_at timestamptz, name text, user_key text, user_id text, anon_id text, session_id text, platform text, "
+               "app_version text, country text, props jsonb) ON CONFLICT DO NOTHING")
+        _call("POST", "/api/v1/sql/query", body={"sql": sql, "params": [json.dumps(chunk)]}, profile=profile, org_id=org_id,
+              project_id=project_id, env_id=env_id, timeout=120.0)
+        done += len(chunk)
+    return done
+
+
+@app.command("export")
+def export(since: str | None = typer.Option(None, "--since", help="ISO date (default: 7 days ago)"),
+           until: str | None = typer.Option(None, "--until"), fmt: str = typer.Option("csv", "--format", help="csv | ndjson"),
+           names: str | None = typer.Option(None, "--names", help="comma-separated event names"),
+           out: Path | None = typer.Option(None, "--out", help="file to write (default: stdout)"),
+           to_db: bool = typer.Option(False, "--to-db", help="copy into a table in the project's own Postgres"),
+           table: str = typer.Option("sovaria_analytics.events", "--table"),
+           limit: int = typer.Option(1_000_000, "--limit", min=1, max=5_000_000),
+           profile: str | None = _PROFILE, org_id: str | None = _ORG, project_id: str | None = _PROJECT,
+           env_id: str | None = _ENV) -> None:
+    """Raw events (analytics.export_sql). --to-db makes them SQL-queryable next to your app's tables."""
+    if fmt not in ("csv", "ndjson"):
+        raise typer.BadParameter("--format is csv or ndjson")
+    if to_db and not _TABLE.fullmatch(table):
+        raise typer.BadParameter("--table is [schema.]name in lower case")
+    params = {"format": "ndjson" if to_db else fmt, "limit": str(limit), **({"since": since} if since else {}),
+              **({"until": until} if until else {}), **({"names": names} if names else {})}
+    data = _call("GET", f"{BASE}/export", params=params, profile=profile, org_id=org_id, project_id=project_id, env_id=env_id,
+                 timeout=600.0)
+    text = data.get("text", "") if isinstance(data, dict) else str(data)
+    if to_db:
+        rows = [json.loads(line) for line in text.splitlines() if line.strip()]
+        n = _to_db(rows, table, profile=profile, org_id=org_id, project_id=project_id, env_id=env_id)
+        print_success(f"Copied {n} events into {table} (duplicates skipped). Query them with: sov db query \"select … from {table}\"")
+        return
+    if out:
+        out.write_text(text + ("\n" if text and not text.endswith("\n") else ""), encoding="utf-8")
+        print_success(f"Wrote {len(text.splitlines()) - (1 if fmt == 'csv' else 0)} events to {out}")
+    else:
+        typer.echo(text)
+
+
+@app.command("erase")
+def erase(user_key: str, yes: bool = typer.Option(False, "--yes", help="confirm"), profile: str | None = _PROFILE,
+          org_id: str | None = _ORG, project_id: str | None = _PROJECT, env_id: str | None = _ENV) -> None:
+    """Erase one user's analytics (events, properties) and stop collecting theirs. Can't be undone."""
+    if not yes and not typer.confirm(f"Erase all analytics of {user_key}? This can't be undone"):
+        raise typer.Exit(1)
+    data = _call("DELETE", f"{BASE}/users/{quote(user_key, safe=':')}", profile=profile, org_id=org_id, project_id=project_id,
+                 env_id=env_id)
+    print_success(f"Erased {data.get('erased_events', 0)} events of {user_key}")
+
+
+@app.command("settings")
+def settings(require_consent: bool | None = typer.Option(None, "--require-consent/--no-require-consent"),
+             profile: str | None = _PROFILE, org_id: str | None = _ORG, project_id: str | None = _PROJECT,
+             env_id: str | None = _ENV) -> None:
+    """Show (or set) whether only users who consented are recorded."""
+    if require_consent is None:
+        print_json(_call("GET", f"{BASE}/settings", profile=profile, org_id=org_id, project_id=project_id, env_id=env_id))
+        return
+    print_json(_call("PUT", f"{BASE}/settings", body={"require_consent": require_consent}, profile=profile, org_id=org_id,
+                     project_id=project_id, env_id=env_id))

{sovaria_cli-0.3.0 → sovaria_cli-0.5.0}/apps/cli/src/commands/auth_enterprise.py

@@ -1,10 +1,11 @@
 """Enterprise auth for a project's app users: SCIM 2.0 provisioning and blocking auth hooks.
 
+    sov saml list | add NAME --domain acme.com --metadata idp.xml | enable ID | disable ID | remove ID [--yes]
     sov scim status | token [--yes] | revoke [--yes]
     sov auth-hooks list | set before-sign-in --url https://… [--fail open] [--timeout-ms 1500] | set before-create
         --function check-signup | test before-create [--email a@b.co] | delete before-create [--yes]
 
-Both need a project owner/admin; plan keys auth.scim (Team+) and auth.blocking_hooks (Pro+).
+All need a project owner/admin; plan keys res.sso (Team+), auth.scim (Team+) and auth.blocking_hooks (Pro+).
 """
 
 from __future__ import annotations
@@ -15,11 +16,13 @@ from apps.cli.src.utils.api_client import CLIRequestError, call_api
 from apps.cli.src.utils.display import handle_cli_error, print_json
 from apps.cli.src.utils.premium_display import run_with_spinner
 
+saml_app = typer.Typer(help="SAML single sign-on for your app's users: one connection per customer identity provider")
 scim_app = typer.Typer(help="SCIM 2.0 provisioning of app users and groups (Okta, Entra ID, Google Workspace …)")
 hooks_app = typer.Typer(help="Blocking auth hooks: before-create and before-sign-in (refuse or add custom claims)")
 
-_EVENTS = {"before-create": "before-create", "before_create": "before-create",
-           "before-sign-in": "before-sign-in", "before_sign_in": "before-sign-in"}
+_HOOK_EVENTS = ("before-create", "before-sign-in", "password-verification-attempt", "mfa-verification-attempt",
+                "send-email", "send-sms")
+_EVENTS = {**{e: e for e in _HOOK_EVENTS}, **{e.replace("-", "_"): e for e in _HOOK_EVENTS}}
 
 
 def _call(method: str, path: str, message: str, *, body=None, profile=None, org_id=None, project_id=None):
@@ -34,10 +37,82 @@ def _call(method: str, path: str, message: str, *, body=None, profile=None, org_
 def _event(raw: str) -> str:
     event = _EVENTS.get((raw or "").strip().lower())
     if event is None:
-        raise typer.BadParameter("event is before-create or before-sign-in")
+        raise typer.BadParameter("event is one of: " + ", ".join(_HOOK_EVENTS))
     return event
 
 
+# ── SAML ──────────────────────────────────────────────────────────────────────
+
+
+@saml_app.command("list")
+def saml_list(
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+) -> None:
+    """The project's SAML connections, with the ACS URL and entity ID to give each IdP admin."""
+    print_json(_call("GET", "/api/v1/auth/saml/connections", "Loading SAML connections…", profile=profile,
+                     org_id=org_id, project_id=project_id))
+
+
+@saml_app.command("add")
+def saml_add(
+    name: str = typer.Argument(..., help='A name, like "Acme (Okta)"'),
+    domain: list[str] = typer.Option(..., "--domain", "-d", help="Email domain this IdP signs in (repeat for more)"),
+    metadata: typer.FileText | None = typer.Option(None, "--metadata", help="The IdP's metadata XML file"),
+    entity_id: str | None = typer.Option(None, "--entity-id", help="IdP entity ID (instead of --metadata)"),
+    sso_url: str | None = typer.Option(None, "--sso-url", help="IdP HTTP-Redirect sign-in URL (instead of --metadata)"),
+    certificate: typer.FileText | None = typer.Option(None, "--certificate", help="IdP signing certificate PEM file"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+) -> None:
+    """Connect a customer's identity provider (metadata XML, or entity ID + sign-in URL + certificate)."""
+    body: dict = {"name": name, "domains": domain}
+    if metadata is not None:
+        body["metadata_xml"] = metadata.read()
+    elif entity_id and sso_url and certificate is not None:
+        body.update(idp_entity_id=entity_id, idp_sso_url=sso_url, idp_certificate_pem=certificate.read())
+    else:
+        raise typer.BadParameter("give --metadata, or --entity-id, --sso-url and --certificate")
+    print_json(_call("POST", "/api/v1/auth/saml/connections", "Adding the connection…", body=body, profile=profile,
+                     org_id=org_id, project_id=project_id))
+
+
+def _toggle(connection_id: str, enabled: bool, profile, org_id, project_id) -> None:
+    print_json(_call("PATCH", f"/api/v1/auth/saml/connections/{connection_id}", "Saving…", body={"enabled": enabled},
+                     profile=profile, org_id=org_id, project_id=project_id))
+
+
+@saml_app.command("enable")
+def saml_enable(connection_id: str, profile: str | None = typer.Option(None, "--profile"),
+                org_id: str | None = typer.Option(None, "--org"), project_id: str | None = typer.Option(None, "--project")) -> None:
+    """Turn a connection on."""
+    _toggle(connection_id, True, profile, org_id, project_id)
+
+
+@saml_app.command("disable")
+def saml_disable(connection_id: str, profile: str | None = typer.Option(None, "--profile"),
+                 org_id: str | None = typer.Option(None, "--org"), project_id: str | None = typer.Option(None, "--project")) -> None:
+    """Turn a connection off (its users keep their accounts)."""
+    _toggle(connection_id, False, profile, org_id, project_id)
+
+
+@saml_app.command("remove")
+def saml_remove(
+    connection_id: str,
+    yes: bool = typer.Option(False, "--yes", "-y"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+) -> None:
+    """Remove a connection: its domains can no longer sign in with SSO (accounts stay)."""
+    if not yes:
+        typer.confirm("Remove this SAML connection? Its users can no longer sign in with SSO.", abort=True)
+    _call("DELETE", f"/api/v1/auth/saml/connections/{connection_id}", "Removing…", profile=profile,
+          org_id=org_id, project_id=project_id)
+
+
 # ── SCIM ──────────────────────────────────────────────────────────────────────
 
 
@@ -99,7 +174,7 @@ def hooks_list(
 
 @hooks_app.command("set")
 def hooks_set(
-    event: str = typer.Argument(..., help="before-create or before-sign-in"),
+    event: str = typer.Argument(..., help="before-create, before-sign-in, password-verification-attempt, mfa-verification-attempt, send-email or send-sms"),
     url: str | None = typer.Option(None, "--url", help="https webhook"),
     function: str | None = typer.Option(None, "--function", help="A project function's name"),
     fail: str = typer.Option("closed", "--fail", help="closed (refuse when the hook fails) or open (let it through)"),
@@ -130,7 +205,7 @@ def hooks_set(
 
 @hooks_app.command("test")
 def hooks_test(
-    event: str = typer.Argument(..., help="before-create or before-sign-in"),
+    event: str = typer.Argument(..., help="before-create, before-sign-in, password-verification-attempt, mfa-verification-attempt, send-email or send-sms"),
     email: str | None = typer.Option(None, "--email"),
     profile: str | None = typer.Option(None, "--profile"),
     org_id: str | None = typer.Option(None, "--org"),
@@ -143,7 +218,7 @@ def hooks_test(
 
 @hooks_app.command("delete")
 def hooks_delete(
-    event: str = typer.Argument(..., help="before-create or before-sign-in"),
+    event: str = typer.Argument(..., help="before-create, before-sign-in, password-verification-attempt, mfa-verification-attempt, send-email or send-sms"),
     yes: bool = typer.Option(False, "--yes", "-y"),
     profile: str | None = typer.Option(None, "--profile"),
     org_id: str | None = typer.Option(None, "--org"),

{sovaria_cli-0.3.0 → sovaria_cli-0.5.0}/apps/cli/src/commands/auth_product.py

@@ -197,6 +197,47 @@ def set_roles(
     print_json(result)
 
 
+@app.command("update")
+def update_user(
+    user_id: str = typer.Argument(..., help="The app user's id"),
+    app_metadata: str | None = typer.Option(None, "--app-metadata", help='JSON object, e.g. \'{"tier": "gold"}\''),
+    user_metadata: str | None = typer.Option(None, "--user-metadata", help="JSON object"),
+    claims: str | None = typer.Option(None, "--claims", help="Custom claims (JSON object) in every token"),
+    email_verified: bool | None = typer.Option(None, "--email-verified/--email-unverified"),
+    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:
+    """Set an app user's app_metadata, user_metadata, custom claims or email_verified (null in JSON removes a key)."""
+    import json as _json
+
+    body: dict = {}
+    for key, raw in (("app_metadata", app_metadata), ("user_metadata", user_metadata), ("custom_claims", claims)):
+        if raw is not None:
+            try:
+                value = _json.loads(raw)
+            except ValueError as exc:
+                raise typer.BadParameter(f"--{key.replace('_', '-')} must be a JSON object") from exc
+            if not isinstance(value, dict):
+                raise typer.BadParameter(f"--{key.replace('_', '-')} must be a JSON object")
+            body[key] = value
+    if email_verified is not None:
+        body["email_verified"] = email_verified
+    if not body:
+        raise typer.BadParameter("Nothing to change")
+    try:
+        result = run_with_spinner(
+            "Updating the user…",
+            lambda: call_api(method="PATCH", path=_project_auth_path(profile, project_id, f"/users/{quote(user_id, safe='')}"),
+                             profile=profile, require_scope=True, **_scope_args(org_id, project_id, env_id), body=body),
+            success="User updated",
+        )
+    except CLIRequestError as exc:
+        handle_cli_error(exc)
+    print_json(result)
+
+
 @app.command("create")
 def create_user(
     email: str = typer.Option(..., "--email"),