sovaria-cli 0.2.8__tar.gz → 0.2.11__tar.gz

{sovaria_cli-0.2.8 → sovaria_cli-0.2.11}/.gitignore

@@ -8,3 +8,5 @@ dist/
 .env.*
 !.env.example
 !.env.*.example
+
+.venv/

{sovaria_cli-0.2.8 → sovaria_cli-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sovaria-cli
-Version: 0.2.8
+Version: 0.2.11
 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.4.0
+Requires-Dist: sovaria-sdk==0.4.6
 Requires-Dist: tomli-w>=1.2.0
 Requires-Dist: typer>=0.17.4
 Provides-Extra: dev
@@ -22,13 +22,22 @@ 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.4.0; extra == 'mcp'
+Requires-Dist: sovaria-sdk[mcp]==0.4.6; extra == 'mcp'
 Description-Content-Type: text/markdown
 
 # Sovaria CLI
 
 Operator CLI for gateway-backed Sovaria project and platform workflows.
 
+## Install
+
+```bash
+npm install -g @sovaria/cli   # or: npx @sovaria/cli --help
+pip install sovaria-cli       # same CLI from PyPI
+```
+
+Both need Python 3.11+. The npm package sets up a private environment in `~/.sovaria/npm-cli` on first run.
+
 ## Run
 
 Examples below use `sov ...` command syntax.

{sovaria_cli-0.2.8 → sovaria_cli-0.2.11}/apps/cli/README.md

@@ -2,6 +2,15 @@
 
 Operator CLI for gateway-backed Sovaria project and platform workflows.
 
+## Install
+
+```bash
+npm install -g @sovaria/cli   # or: npx @sovaria/cli --help
+pip install sovaria-cli       # same CLI from PyPI
+```
+
+Both need Python 3.11+. The npm package sets up a private environment in `~/.sovaria/npm-cli` on first run.
+
 ## Run
 
 Examples below use `sov ...` command syntax.

{sovaria_cli-0.2.8 → sovaria_cli-0.2.11}/apps/cli/src/__init__.py

@@ -1,3 +1,3 @@
 """Sovaria CLI — sov command."""
 
-__version__ = "0.2.8"
+__version__ = "0.2.11"

{sovaria_cli-0.2.8 → sovaria_cli-0.2.11}/apps/cli/src/commands/api.py

@@ -13,7 +13,7 @@ app = typer.Typer(help="Raw gateway API calls")
 @app.command("call")
 def call_command(
     method: str = typer.Argument(..., help="HTTP method, e.g. GET/POST"),
-    path: str = typer.Argument(..., help="Gateway path, e.g. /api/v1/system/engines/health"),
+    path: str = typer.Argument(..., help="Gateway path, e.g. /api/v1/auth/me"),
     body: str | None = typer.Option(None, "--body", help="JSON request body"),
     query: str | None = typer.Option(None, "--query", help="JSON object query params"),
     profile: str | None = typer.Option(None, "--profile"),
@@ -30,12 +30,19 @@ def call_command(
         if parsed_query is not None and not isinstance(parsed_query, dict):
             raise CLIRequestError("--query must be a JSON object")
 
+        # A query string written in the path (`/x?limit=4`) is kept: the HTTP client would
+        # otherwise replace it with --query's params.
+        from urllib.parse import parse_qsl
+
+        bare_path, _, inline = path.partition("?")
+        params = dict(parse_qsl(inline, keep_blank_values=True))
+        params.update({str(k): str(v) for k, v in (parsed_query or {}).items()})
         result = call_api(
             method=method,
-            path=path,
+            path=bare_path,
             profile=profile,
             body=parsed_body,
-            params={str(k): str(v) for k, v in (parsed_query or {}).items()},
+            params=params,
             require_auth=not no_auth,
             require_scope=require_scope,
             org_id=org_id,

{sovaria_cli-0.2.8 → sovaria_cli-0.2.11}/apps/cli/src/commands/audit.py

@@ -122,20 +122,16 @@ def sim_run(
     if parsed_context is not None and not isinstance(parsed_context, dict):
         raise CLIRequestError("--context must be a JSON object")
 
-    premium_api(
-        f"Running simulation '{simulation_name}'…",
-        success="Completed",
+    # The name/operations are accepted for older scripts; the run covers the whole project
+    # (started in the background and polled — a full run outlasts one request).
+    from apps.cli.src.commands.sim import run_simulation_api
+    from apps.cli.src.utils.display import print_json
+    from apps.cli.src.utils.premium_display import run_with_spinner
+
+    print_json(
+        run_with_spinner(f"Running simulation '{simulation_name}'…", lambda: run_simulation_api(profile=profile),
+                         success="Completed"),
         title="Simulation",
-        method="POST",
-        path="/api/v1/sim/run",
-        profile=profile,
-        body={
-            "simulation_name": simulation_name,
-            "operations": parsed_ops,
-            "echo_flag": True,
-            "include_execution_tree": include_execution_tree,
-            "context": parsed_context or {},
-        },
     )
 
 

{sovaria_cli-0.2.8 → sovaria_cli-0.2.11}/apps/cli/src/commands/auth_product.py

@@ -59,27 +59,48 @@ def _project_auth_path(profile: str | None, project_id: str | None, suffix: str)
 
 @app.command("users")
 def list_users(
+    search: str | None = typer.Option(None, "--search", "-s", help="Part of an email, or an exact user id"),
+    status: str | None = typer.Option(None, "--status", help="active or banned"),
+    limit: int = typer.Option(50, "--limit", min=1, max=500),
+    cursor: str | None = typer.Option(None, "--cursor", help="next_cursor from the previous page"),
     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:
-    """List product users for the resolved org/project scope."""
+    """One page of app users (newest first). Search and status filter on the server."""
+    if status and status not in ("active", "banned"):
+        handle_cli_error(CLIRequestError("--status must be 'active' or 'banned'"))
+    params = {"limit": str(limit)}
+    if search:
+        params["q"] = search
+    if status:
+        params["status"] = status
+    if cursor:
+        params["cursor"] = cursor
+    paging: dict[str, str] = {}
     try:
-        result = run_with_spinner(
+        users = run_with_spinner(
             "Loading app users…",
             lambda: call_api(
                 method="GET",
                 path=_project_auth_path(profile, project_id, "/users"),
                 profile=profile,
+                params=params,
                 require_scope=True,
+                page_headers=paging,
                 **_scope_args(org_id, project_id, env_id),
             ),
             success="Users loaded",
         )
     except CLIRequestError as exc:
         handle_cli_error(exc)
-    print_json(result, title="App users")
+    total = paging.get("x-total-count")
+    print_json(
+        {"users": users, "total": int(total) if total and total.isdigit() else None,
+         "next_cursor": paging.get("x-next-cursor")},
+        title="App users",
+    )
 
 
 @app.command("ban")

sovaria_cli-0.2.11/apps/cli/src/commands/builds.py

@@ -0,0 +1,128 @@
+"""App builds (plan D3): check a build (schema, access rules, functions, rules tests) against the project and open
+it as a pull request on the linked GitHub repository. Sovariq writes builds from a description; you can also
+write one by hand as JSON or YAML::
+
+    title: Recipe sharing
+    description: People share recipes; authors edit their own.
+    migration:
+      name: recipes
+      up_sql: |
+        create table recipes (id uuid primary key default gen_random_uuid(), author_id uuid not null default auth.uid(), title text not null);
+        alter table recipes enable row level security;
+        alter table recipes force row level security;
+        create policy read_all on recipes for select using (auth.uid() is not null);
+        create policy own on recipes for all using (author_id = auth.uid()) with check (author_id = auth.uid());
+      down_sql: drop table recipes;
+    policies: []          # [{id, spl}] access rules (Guard), e.g. for functions app users call
+    functions: []         # [{name, runtime: python3|node, files: {main.py: ...}}]
+    tests: []             # rules test cases: {name, as, do, on, expect}
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from urllib.parse import quote
+
+import typer
+import yaml
+
+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, print_warning
+from apps.cli.src.utils.premium_display import run_with_spinner
+
+app = typer.Typer(help="App builds: check schema, rules, functions and tests, then open them as a pull request")
+
+_ORG = typer.Option(None, "--org")
+_PROJECT = typer.Option(None, "--project")
+_ENV = typer.Option(None, "--env")
+_PROFILE = typer.Option(None, "--profile")
+_MARK = {"passed": "PASS", "warning": "WARN", "skipped": "SKIP", "failed": "FAIL"}
+
+
+def _call(method: str, path: str, *, profile, org_id, project_id, env_id, body=None, params=None):
+    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)
+    except CLIRequestError as exc:
+        handle_cli_error(exc)
+
+
+def _print_checks(checks: list[dict]) -> None:
+    for c in checks:
+        typer.echo(f"{_MARK.get(c.get('status'), '?'):<5} {c.get('name')}: {c.get('detail', '')}")
+        for case in c.get("cases") or []:
+            if not case.get("passed"):
+                typer.echo(f"        ✗ {case['name']}: expected {case['expect']}, got {case['got']} ({case.get('reason')})")
+
+
+@app.command("check")
+def check(
+    path: Path = typer.Argument(..., help="Build file (.json, .yaml or .yml)"),
+    profile: str | None = _PROFILE, org_id: str | None = _ORG, project_id: str | None = _PROJECT, env_id: str | None = _ENV,
+) -> None:
+    """Check a build against the project — nothing changes. Exit 1 when a check fails."""
+    try:
+        raw = path.read_text(encoding="utf-8")
+        build = json.loads(raw) if path.suffix == ".json" else yaml.safe_load(raw)
+    except (OSError, ValueError, yaml.YAMLError) as exc:
+        print_warning(f"{path}: {exc}")
+        raise typer.Exit(2) from exc
+    out = run_with_spinner("Checking the build…", lambda: _call("POST", "/api/v1/fn/builds/check", body={"build": build},
+                                                                profile=profile, org_id=org_id, project_id=project_id,
+                                                                env_id=env_id)) or {}
+    _print_checks(out.get("checks") or [])
+    typer.echo(f"\nBuild {out.get('id')}: {len(out.get('files') or [])} file(s)")
+    for f in out.get("files") or []:
+        typer.echo(f"  {f['path']}")
+    if not out.get("ok"):
+        print_warning("A check failed: fix the build and check again")
+        raise typer.Exit(1)
+    if out.get("can_open_pull_request"):
+        print_success(f"Ready. Open it as a pull request on {out.get('repository')}: sov builds pr {out.get('id')}")
+    else:
+        print_success("Ready. Link a GitHub repository (Functions › GitHub) to open it as a pull request.")
+
+
+@app.command("pr")
+def pull_request(
+    build_id: str = typer.Argument(..., help="Build id from sov builds check"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Don't ask"),
+    token: str | None = typer.Option(None, "--github-token", envvar="GITHUB_TOKEN",
+                                     help="A GitHub token with repo scope instead of the project's GitHub connection"),
+    profile: str | None = _PROFILE, org_id: str | None = _ORG, project_id: str | None = _PROJECT, env_id: str | None = _ENV,
+) -> None:
+    """Check the build again and open it as a pull request on the linked repository."""
+    if not yes and not typer.confirm(f"Open build {build_id} as a pull request?", default=False):
+        raise typer.Exit(1)
+    out = run_with_spinner("Opening the pull request…", lambda: _call(
+        "POST", f"/api/v1/fn/builds/{quote(build_id, safe='')}/pull-request", body={"token": token} if token else {},
+        profile=profile, org_id=org_id, project_id=project_id, env_id=env_id)) or {}
+    pr = out.get("pull_request") or {}
+    print_success(f"Pull request: {pr.get('url')}" + (" (already open)" if out.get("already_open") else ""))
+
+
+@app.command("list")
+def list_builds(profile: str | None = _PROFILE, org_id: str | None = _ORG, project_id: str | None = _PROJECT,
+                env_id: str | None = _ENV) -> None:
+    """Recent builds of the project."""
+    out = _call("GET", "/api/v1/fn/builds", profile=profile, org_id=org_id, project_id=project_id, env_id=env_id) or {}
+    for b in out.get("builds") or []:
+        typer.echo(f"{b['id']}  {b['status']:<10} {b['title']}  {b.get('pr_url') or ''}")
+
+
+@app.command("show")
+def show(build_id: str = typer.Argument(...), profile: str | None = _PROFILE, org_id: str | None = _ORG,
+         project_id: str | None = _PROJECT, env_id: str | None = _ENV) -> None:
+    """One build: its files, checks and pull request."""
+    print_json(_call("GET", f"/api/v1/fn/builds/{quote(build_id, safe='')}", profile=profile, org_id=org_id,
+                     project_id=project_id, env_id=env_id))
+
+
+@app.command("delete")
+def delete(build_id: str = typer.Argument(...), profile: str | None = _PROFILE, org_id: str | None = _ORG,
+           project_id: str | None = _PROJECT, env_id: str | None = _ENV) -> None:
+    """Forget a build (an opened pull request stays on GitHub)."""
+    _call("DELETE", f"/api/v1/fn/builds/{quote(build_id, safe='')}", profile=profile, org_id=org_id,
+          project_id=project_id, env_id=env_id)
+    print_success(f"Build {build_id} deleted")

{sovaria_cli-0.2.8 → sovaria_cli-0.2.11}/apps/cli/src/commands/chrono.py

@@ -7,6 +7,7 @@ from urllib.parse import quote
 import typer
 
 from apps.cli.src.utils.api_helpers import premium_api, premium_mutate
+from apps.cli.src.utils.display import print_json
 
 app = typer.Typer(help="Chrono timeline and snapshot operations")
 
@@ -230,3 +231,52 @@ def snapshot_restore(
         path=f"/api/v1/chrono/snapshots/{snapshot_id}/restore",
         profile=profile,
     )
+
+
+@app.command("state")
+def state(
+    at: str | None = typer.Option(None, "--at", help="Commit id or ISO time (default: now)"),
+    prefix: str = typer.Option("", "--prefix", help="Only this folder: policies/, schema/, functions/, settings/, storage/, keys/"),
+    timeline: str = typer.Option("main", "--timeline"),
+    names_only: bool = typer.Option(False, "--names-only", help="List files without their contents"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """The project's configuration as it was at a point in time (policies, schema, functions, settings…)."""
+    params = {"timeline": timeline, "prefix": prefix, "contents": "false" if names_only else "true"}
+    if at:
+        params["at"] = at
+    premium_api("Reading the timeline…", title=f"State {'at ' + at if at else 'now'}", method="GET",
+                path="/api/v1/chrono/state", profile=profile, params=params, require_scope=True)
+
+
+@app.command("restore")
+def restore(
+    at: str = typer.Argument(..., help="Commit id or ISO time to go back to"),
+    timeline: str = typer.Option("main", "--timeline"),
+    yes: bool = typer.Option(False, "--yes", help="Apply without asking (after showing the plan)"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Go back to an earlier point: shows what changes back (and who would gain or lose access), then applies it."""
+    from apps.cli.src.utils.output_mode import wants_json
+    from apps.cli.src.utils.premium_display import _console
+
+    plan = premium_api("Comparing then with now…", print=False, method="POST", path="/api/v1/chrono/restore-plan",
+                       profile=profile, body={"at": at, "timeline": timeline}, require_scope=True)
+    if wants_json():
+        print_json(plan)
+    actions = plan.get("actions") or [] if isinstance(plan, dict) else []
+    if not actions:
+        _console.print("Nothing has changed since then.")
+        return
+    for action in actions:
+        mark = "[yellow]manual[/yellow]" if action.get("manual") else "[green]auto[/green]  "
+        _console.print(f"  {mark} {action.get('path')}" + (f"  [dim]{action.get('reason')}[/dim]" if action.get("reason") else ""))
+    for v in ((plan.get("preview") or {}).get("violations") or [])[:10]:
+        _console.print(f"  [red]{str(v.get('severity', '')).upper()}[/red] {v.get('reason')}")
+    if not plan.get("automated"):
+        _console.print("Nothing can be put back automatically.")
+        return
+    if not yes and not typer.confirm(f"Put back {plan.get('automated')} change(s)?", default=False):
+        raise typer.Exit(code=1)
+    premium_mutate("Going back…", success="Done", title="Restore", method="POST", path="/api/v1/chrono/restore",
+                   profile=profile, body={"at": at, "timeline": timeline, "confirm": True}, require_scope=True)

sovaria_cli-0.2.11/apps/cli/src/commands/crashes.py

@@ -0,0 +1,92 @@
+"""`sov crashes`: app crash reports (sov.crashes in the SDK), grouped into issues.
+
+    sov crashes list [--status open|resolved|ignored]
+    sov crashes show <fingerprint>
+    sov crashes resolve <fingerprint>      (reopens by itself if it happens again)
+    sov crashes ignore <fingerprint>
+"""
+
+from __future__ import annotations
+
+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="App crash reports grouped into issues (from sov.crashes in your app)")
+
+
+def _opts(profile, org_id, project_id, env_id) -> dict:
+    return {"profile": profile, "org_id": org_id, "project_id": project_id, "env_id": env_id, "require_scope": True}
+
+
+@app.command("list")
+def crashes_list(
+    status: str | None = typer.Option(None, "--status", help="open | resolved | ignored"),
+    limit: int = typer.Option(50, "--limit", min=1, max=200),
+    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:
+    """Crash issues, most recent first."""
+    if status and status not in ("open", "resolved", "ignored"):
+        raise typer.BadParameter("--status must be open, resolved or ignored")
+    params = {"limit": str(limit), **({"status": status} if status else {})}
+    try:
+        data = call_api(method="GET", path="/api/v1/crashes/issues", params=params, **_opts(profile, org_id, project_id, env_id))
+    except CLIRequestError as exc:
+        handle_cli_error(exc)
+        return
+    if wants_json():
+        print_json(data)
+        return
+    rows = [{"issue": i["fingerprint"][:12], "title": i["title"][:70], "events": i["events"], "users": i["users"],
+             "last seen": i["last_seen"][:19], "status": i["status"]} for i in data.get("issues", [])]
+    print_json(rows, title=f"Crash issues ({len(rows)})")
+
+
+@app.command("show")
+def crashes_show(
+    fingerprint: str,
+    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:
+    """One issue: stack, breadcrumbs, device and release of the latest report."""
+    try:
+        data = call_api(method="GET", path=f"/api/v1/crashes/issues/{quote(fingerprint, safe='')}", **_opts(profile, org_id, project_id, env_id))
+    except CLIRequestError as exc:
+        handle_cli_error(exc)
+        return
+    print_json(data)
+
+
+def _status(fingerprint: str, status: str, profile, org_id, project_id, env_id) -> None:
+    try:
+        call_api(method="POST", path=f"/api/v1/crashes/issues/{quote(fingerprint, safe='')}/status", body={"status": status},
+                 **_opts(profile, org_id, project_id, env_id))
+    except CLIRequestError as exc:
+        handle_cli_error(exc)
+        return
+    print_success(f"Issue {fingerprint[:12]} {status}")
+
+
+@app.command("resolve")
+def crashes_resolve(fingerprint: str, 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:
+    """Mark resolved (it reopens if the crash happens again)."""
+    _status(fingerprint, "resolved", profile, org_id, project_id, env_id)
+
+
+@app.command("ignore")
+def crashes_ignore(fingerprint: str, 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:
+    """Hide an issue you won't fix."""
+    _status(fingerprint, "ignored", profile, org_id, project_id, env_id)