sovaria-cli 0.2.0__py3-none-any.whl

apps/cli/src/commands/realtime.py

@@ -0,0 +1,364 @@
+"""Pulse realtime commands."""
+
+from __future__ import annotations
+
+from typing import TypedDict
+from urllib.parse import quote, urlencode
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api, parse_json_arg, print_json
+from apps.cli.src.utils.config import get_api_url, get_scope
+
+app = typer.Typer(help="Realtime stream and E2EE operations")
+
+
+class ScopeOpts(TypedDict):
+    org_id: str | None
+    project_id: str | None
+    env_id: str | None
+
+
+def _scope_opts(
+    org_id: str | None,
+    project_id: str | None,
+    env_id: str | None,
+) -> ScopeOpts:
+    return {
+        "org_id": org_id,
+        "project_id": project_id,
+        "env_id": env_id,
+    }
+
+
+@app.command("subscribe")
+def subscribe(
+    channel: str = typer.Argument(...),
+    client_id: str = typer.Argument(...),
+    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:
+    """Subscribe a client to a channel."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/rt/stream/subscribe",
+            profile=profile,
+            body={"channel": channel, "client_id": client_id},
+            require_scope=True,
+            **_scope_opts(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("unsubscribe")
+def unsubscribe(
+    channel: str = typer.Argument(...),
+    client_id: str = typer.Argument(...),
+    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:
+    """Unsubscribe a client from a channel."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/rt/stream/unsubscribe",
+            profile=profile,
+            body={"channel": channel, "client_id": client_id},
+            require_scope=True,
+            **_scope_opts(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("presence")
+def presence(
+    channel: str = typer.Argument(...),
+    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:
+    """Show online clients for a channel."""
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/rt/stream/presence/{quote(channel, safe='')}",
+            profile=profile,
+            require_scope=True,
+            **_scope_opts(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("channels")
+def channels(
+    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 active channels in current scope."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/rt/stream/channels",
+            profile=profile,
+            require_scope=True,
+            **_scope_opts(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("replay")
+def replay(
+    channel: str = typer.Argument(...),
+    after: int = typer.Option(0, "--after"),
+    limit: int = typer.Option(200, "--limit"),
+    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:
+    """Replay channel events from a sequence index."""
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/rt/stream/replay/{quote(channel, safe='')}",
+            profile=profile,
+            params={"after": str(after), "limit": str(limit)},
+            require_scope=True,
+            **_scope_opts(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("publish")
+def publish(
+    channel: str = typer.Argument(...),
+    payload: str = typer.Argument(..., help="JSON object payload"),
+    clock: str | None = typer.Option(None, "--clock", help="JSON object clock"),
+    clock_delta: str | None = typer.Option(None, "--clock-delta", help="JSON object clock delta"),
+    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:
+    """Publish a payload on a channel."""
+    try:
+        parsed_payload = parse_json_arg(payload, label="payload")
+        if not isinstance(parsed_payload, dict):
+            raise CLIRequestError("payload must be a JSON object")
+        parsed_clock = parse_json_arg(clock, label="--clock") if clock else None
+        parsed_delta = parse_json_arg(clock_delta, label="--clock-delta") if clock_delta else None
+        if parsed_clock is not None and not isinstance(parsed_clock, dict):
+            raise CLIRequestError("--clock must be a JSON object")
+        if parsed_delta is not None and not isinstance(parsed_delta, dict):
+            raise CLIRequestError("--clock-delta must be a JSON object")
+
+        body = {"payload": parsed_payload}
+        if parsed_clock:
+            body["clock"] = parsed_clock
+        if parsed_delta:
+            body["clock_delta"] = parsed_delta
+
+        result = call_api(
+            method="POST",
+            path=f"/api/v1/rt/stream/publish/{quote(channel, safe='')}",
+            profile=profile,
+            body=body,
+            require_scope=True,
+            **_scope_opts(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    typer.echo(print_json(result))
+
+
+@app.command("e2ee-bootstrap")
+def e2ee_bootstrap(
+    channel: str = typer.Argument(...),
+    ttl_seconds: int = typer.Option(86_400, "--ttl"),
+    force_new: bool = typer.Option(False, "--force-new"),
+    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:
+    """Create or fetch active E2EE key material."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/rt/e2ee/keys/bootstrap",
+            profile=profile,
+            body={"channel": channel, "ttl_seconds": ttl_seconds, "force_new": force_new},
+            require_scope=True,
+            **_scope_opts(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("e2ee-rotate")
+def e2ee_rotate(
+    channel: str = typer.Argument(...),
+    ttl_seconds: int = typer.Option(86_400, "--ttl"),
+    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:
+    """Rotate E2EE key material."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/rt/e2ee/keys/rotate",
+            profile=profile,
+            body={"channel": channel, "ttl_seconds": ttl_seconds},
+            require_scope=True,
+            **_scope_opts(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("e2ee-revoke")
+def e2ee_revoke(
+    channel: str = typer.Argument(...),
+    key_id: str | None = typer.Option(None, "--key-id"),
+    reason: str | None = typer.Option(None, "--reason"),
+    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:
+    """Revoke an E2EE key."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/rt/e2ee/keys/revoke",
+            profile=profile,
+            body={"channel": channel, "key_id": key_id, "reason": reason},
+            require_scope=True,
+            **_scope_opts(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("e2ee-list")
+def e2ee_list(
+    channel: str = typer.Argument(...),
+    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 E2EE keys for a channel."""
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/rt/e2ee/keys/{quote(channel, safe='')}",
+            profile=profile,
+            require_scope=True,
+            **_scope_opts(org_id, project_id, env_id),
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("ws-url")
+def ws_url(
+    channel: str = typer.Argument(...),
+    profile: str | None = typer.Option(None, "--profile"),
+    ticket: str | None = typer.Option(None, "--ticket", help="Use an already issued WS ticket"),
+    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:
+    """Generate websocket URL for Pulse via gateway."""
+    base = get_api_url(profile).rstrip("/")
+    if base.startswith("https://"):
+        ws_base = "wss://" + base[len("https://") :]
+    elif base.startswith("http://"):
+        ws_base = "ws://" + base[len("http://") :]
+    else:
+        ws_base = f"ws://{base}"
+
+    scope = get_scope(profile)
+    resolved_org = (org_id or scope.get("org_id") or "").strip()
+    resolved_project = (project_id or scope.get("project_id") or "").strip()
+    resolved_env = (env_id or scope.get("env_id") or "").strip()
+
+    if not resolved_org or not resolved_project:
+        typer.echo(
+            "Missing scope. Set --org/--project or run: sov scope set <org_id> <project_id>",
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    resolved_ticket = (ticket or "").strip()
+    if not resolved_ticket:
+        try:
+            result = call_api(
+                method="POST",
+                path="/api/v1/auth/ws-ticket",
+                profile=profile,
+                body={
+                    "channel": channel,
+                    "org_id": resolved_org,
+                    "project_id": resolved_project,
+                    **({"env_id": resolved_env} if resolved_env else {}),
+                },
+                require_scope=True,
+                org_id=resolved_org,
+                project_id=resolved_project,
+                env_id=resolved_env or None,
+            )
+        except CLIRequestError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(1) from exc
+        resolved_ticket = str(result.get("ticket") or "").strip() if isinstance(result, dict) else ""
+    if not resolved_ticket:
+        typer.echo("Gateway did not return a websocket ticket.", err=True)
+        raise typer.Exit(1)
+
+    query = {
+        "ticket": resolved_ticket,
+        "org_id": resolved_org,
+        "project_id": resolved_project,
+    }
+    if resolved_env:
+        query["env_id"] = resolved_env
+
+    safe_channel = quote(channel, safe="")
+    typer.echo(f"{ws_base}/api/v1/rt/ws/{safe_channel}?{urlencode(query)}")

apps/cli/src/commands/scope.py

@@ -0,0 +1,42 @@
+"""Scope management commands for org/project/env defaults."""
+
+from __future__ import annotations
+
+import typer
+
+from apps.cli.src.utils.config import clear_scope, get_scope, set_scope
+
+app = typer.Typer(help="Manage default org/project/env scope")
+
+
+@app.command("show")
+def show_scope(profile: str | None = typer.Option(None, "--profile")) -> None:
+    """Show currently configured default scope."""
+    scope = get_scope(profile)
+    typer.echo(f"org_id     : {scope.get('org_id') or '-'}")
+    typer.echo(f"project_id : {scope.get('project_id') or '-'}")
+    typer.echo(f"env_id     : {scope.get('env_id') or '-'}")
+
+
+@app.command("set")
+def set_scope_cmd(
+    org_id: str = typer.Argument(..., help="Organization UUID"),
+    project_id: str = typer.Argument(..., help="Project UUID"),
+    env_id: str | None = typer.Option(None, "--env", help="Environment UUID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Persist default scope for future CLI calls."""
+    set_scope(
+        org_id=org_id,
+        project_id=project_id,
+        env_id=env_id,
+        profile=profile,
+    )
+    typer.echo("Default scope saved.")
+
+
+@app.command("clear")
+def clear_scope_cmd(profile: str | None = typer.Option(None, "--profile")) -> None:
+    """Clear default scope for the active profile."""
+    clear_scope(profile)
+    typer.echo("Default scope cleared.")