gravi-cli 0.2.2__tar.gz → 0.2.4__tar.gz

{gravi_cli-0.2.2 → gravi_cli-0.2.4}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.2.2"
+current_version = "0.2.4"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{gravi_cli-0.2.2 → gravi_cli-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gravi-cli
-Version: 0.2.2
+Version: 0.2.4
 Summary: CLI tool for Gravitate infrastructure management
 Project-URL: Homepage, https://github.com/gravitate/mom
 Project-URL: Documentation, https://github.com/gravitate/mom/tree/main/cli

{gravi_cli-0.2.2 → gravi_cli-0.2.4}/gravi_cli/__init__.py

@@ -6,4 +6,4 @@ allowing developers to authenticate, manage tokens, and access instance
 configurations and credentials.
 """
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{gravi_cli-0.2.2 → gravi_cli-0.2.4}/gravi_cli/cli.py

@@ -32,6 +32,7 @@ from .exceptions import (
     APIError,
     RateLimitError,
     ConfigError,
+    PermissionDeniedError,
 )
 
 
@@ -393,6 +394,39 @@ def config(instance_key, format):
         sys.exit(1)
 
 
+@main.command()
+@click.argument("instance_key")
+@click.option(
+    "--json",
+    "output_json",
+    is_flag=True,
+    help="Output as JSON for scripting",
+)
+def token(instance_key, output_json):
+    """Get access and refresh tokens for an instance."""
+    try:
+        token_data = get_instance_token(instance_key)
+
+        if output_json:
+            click.echo(json.dumps({
+                "access_token": token_data.get("access_token", ""),
+                "refresh_token": token_data.get("refresh_token", ""),
+            }))
+        else:
+            click.echo(f"AccessToken: {token_data.get('access_token', 'N/A')}")
+            click.echo(f"RefreshToken: {token_data.get('refresh_token', 'N/A')}")
+
+    except NotAuthenticatedError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+    except PermissionDeniedError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
 # Add missing import for timedelta
 from datetime import timedelta
 
@@ -448,5 +482,365 @@ def dbtun(burner_id):
         sys.exit(1)
 
 
+# ============================================================================
+# Burner Commands
+# ============================================================================
+
+@main.group()
+def burner():
+    """Manage ephemeral burner instances."""
+    pass
+
+
+def poll_operation_until_complete(
+    client: MomClient,
+    token: str,
+    operation_id: str,
+    show_progress: bool = True,
+    poll_interval: float = 2.0,
+    timeout: float = 600.0,
+) -> dict:
+    """
+    Poll an operation until it completes or fails.
+
+    Args:
+        client: MomClient instance
+        token: Access token
+        operation_id: Operation ID to poll
+        show_progress: Whether to print progress
+        poll_interval: Seconds between polls
+        timeout: Maximum time to wait
+
+    Returns:
+        Final operation status dict
+    """
+    start_time = time.time()
+    last_step = None
+
+    while True:
+        if time.time() - start_time > timeout:
+            return {"status": "failed", "error_message": "Timeout waiting for operation"}
+
+        status = client.get_operation_status(operation_id, token)
+
+        if show_progress:
+            current_step = status.get("current_step")
+            progress = status.get("progress_percent", 0)
+            if current_step and current_step != last_step:
+                click.echo(f"\n  {current_step}...", nl=False)
+                last_step = current_step
+            else:
+                click.echo(".", nl=False)
+
+        if status["status"] in ("completed", "failed"):
+            if show_progress:
+                click.echo()
+            return status
+
+        time.sleep(poll_interval)
+
+
+@burner.command("start")
+@click.option("--ttl", "ttl_hours", default=2, type=int, help="Time-to-live in hours (1-168)")
+@click.option("--sheet-id", default=None, help="Google Sheet ID for full seeding")
+@click.option("--source-env", default=None, help="Source environment to copy from")
+@click.option("--simple-demand", is_flag=True, help="Use even demand distribution")
+@click.option("--sync", is_flag=True, help="Wait for burner to be ready")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def burner_start(ttl_hours, sheet_id, source_env, simple_demand, sync, output_json):
+    """Create a new burner instance.
+
+    Examples:
+
+        gravi burner start                      # Quick barebone burner
+
+        gravi burner start --ttl 8              # 8 hour TTL
+
+        gravi burner start --sync               # Wait until ready
+
+        gravi burner start --sheet-id ABC123    # Full seed from sheet
+    """
+    try:
+        mom_token = get_mom_token()
+        mom_url = get_mom_url()
+        client = MomClient(mom_url)
+
+        # Determine seed level based on options
+        seed_level = "barebone"
+        if sheet_id:
+            seed_level = "full"
+        elif source_env:
+            seed_level = "copy"
+
+        # Initiate creation
+        response = client.create_burner(
+            access_token=mom_token,
+            ttl_hours=ttl_hours,
+            sheet_id=sheet_id,
+            source_env=source_env,
+            seed_level=seed_level,
+            simple_demand=simple_demand,
+        )
+
+        burner_id = response["burner_id"]
+        operation_id = response["operation_id"]
+
+        if not sync:
+            # Async mode: just output the operation info and exit
+            if output_json:
+                click.echo(json.dumps(response))
+            else:
+                click.echo(f"Burner '{burner_id}' creation started")
+                click.echo(f"  Operation ID: {operation_id}")
+                click.echo(f"\nUse 'gravi burner status {burner_id}' to check status")
+            return
+
+        # Sync mode: poll until complete
+        if not output_json:
+            click.echo(f"Creating burner '{burner_id}'", nl=False)
+
+        final_result = poll_operation_until_complete(
+            client, mom_token, operation_id,
+            show_progress=(not output_json)
+        )
+
+        if final_result["status"] == "completed":
+            # Fetch the burner details
+            burner_info = client.get_burner(burner_id, mom_token)
+
+            if output_json:
+                click.echo(json.dumps(burner_info))
+            else:
+                click.echo(f"\nBurner ready:")
+                click.echo(f"  ID:      {burner_info['burner_id']}")
+                click.echo(f"  URL:     https://{burner_info['url']}")
+                click.echo(f"  Expires: {burner_info['expires_at']}")
+        else:
+            error_msg = final_result.get("error_message", "Unknown error")
+            if output_json:
+                click.echo(json.dumps({"error": error_msg, "burner_id": burner_id}))
+            else:
+                click.echo(f"\nError: {error_msg}", err=True)
+            sys.exit(1)
+
+    except NotAuthenticatedError:
+        click.echo("Error: Please run 'gravi login' first", err=True)
+        sys.exit(1)
+    except RateLimitError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+    except APIError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@burner.command("delete")
+@click.argument("burner_id")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def burner_delete(burner_id, output_json):
+    """Delete a burner instance.
+
+    Examples:
+
+        gravi burner delete tank
+
+        gravi burner delete pump --json
+    """
+    try:
+        mom_token = get_mom_token()
+        mom_url = get_mom_url()
+        client = MomClient(mom_url)
+
+        response = client.delete_burner(burner_id, mom_token)
+
+        if output_json:
+            click.echo(json.dumps(response))
+        else:
+            click.echo(f"Burner '{burner_id}' deletion initiated")
+            click.echo(f"  Operation ID: {response['operation_id']}")
+
+    except NotAuthenticatedError:
+        click.echo("Error: Please run 'gravi login' first", err=True)
+        sys.exit(1)
+    except APIError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@burner.command("status")
+@click.argument("burner_id")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def burner_status(burner_id, output_json):
+    """Get detailed status of a burner.
+
+    Examples:
+
+        gravi burner status tank
+
+        gravi burner status pump --json
+    """
+    try:
+        mom_token = get_mom_token()
+        mom_url = get_mom_url()
+        client = MomClient(mom_url)
+
+        burner_info = client.get_burner(burner_id, mom_token)
+
+        if output_json:
+            click.echo(json.dumps(burner_info))
+        else:
+            click.echo(f"Burner: {burner_info['burner_id']}")
+            click.echo("=" * 40)
+            click.echo(f"Status:     {burner_info['status']}")
+            click.echo(f"URL:        https://{burner_info['url']}")
+            click.echo(f"Created by: {burner_info['created_by']}")
+            click.echo(f"Created:    {burner_info['created_at']}")
+            click.echo(f"Expires:    {burner_info['expires_at']}")
+            click.echo(f"TTL:        {burner_info['ttl_hours']} hours")
+            click.echo(f"Build:      {burner_info['build']}")
+            click.echo(f"Seed level: {burner_info['seed_level']}")
+            if burner_info.get('custom_name'):
+                click.echo(f"Name:       {burner_info['custom_name']}")
+            if burner_info.get('sheet_id'):
+                click.echo(f"Sheet ID:   {burner_info['sheet_id']}")
+
+    except NotAuthenticatedError:
+        click.echo("Error: Please run 'gravi login' first", err=True)
+        sys.exit(1)
+    except APIError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@burner.command("pods")
+@click.argument("burner_id")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def burner_pods(burner_id, output_json):
+    """List pods in a burner instance.
+
+    Shows all pods grouped by deployment with their status.
+
+    Examples:
+
+        gravi burner pods tank
+
+        gravi burner pods pump --json
+    """
+    try:
+        mom_token = get_mom_token()
+        mom_url = get_mom_url()
+        client = MomClient(mom_url)
+
+        data = client.list_burner_pods(burner_id, mom_token)
+
+        if output_json:
+            click.echo(json.dumps(data))
+        else:
+            click.echo(f"Pods in burner '{burner_id}' ({data['namespace']})")
+            click.echo("=" * 60)
+
+            for deployment in data.get("deployments", []):
+                ready = deployment["ready_replicas"]
+                desired = deployment["desired_replicas"]
+                status_icon = "✓" if ready == desired else "○"
+                click.echo(f"\n{status_icon} {deployment['name']} ({ready}/{desired} ready)")
+
+                for pod in deployment.get("pods", []):
+                    pod_status = pod.get("status", "Unknown")
+                    restarts = pod.get("restart_count", 0)
+                    restart_str = f" (restarts: {restarts})" if restarts > 0 else ""
+                    status_color = "green" if pod_status == "Running" else "yellow"
+                    click.echo(f"    {pod['name']}: {pod_status}{restart_str}")
+
+    except NotAuthenticatedError:
+        click.echo("Error: Please run 'gravi login' first", err=True)
+        sys.exit(1)
+    except APIError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@burner.command("logs")
+@click.argument("burner_id")
+@click.argument("pod_name")
+@click.option("--tail", "-n", "tail_lines", default=100, type=int, help="Number of lines (default: 100)")
+@click.option("--container", "-c", default=None, help="Container name (optional)")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def burner_logs(burner_id, pod_name, tail_lines, container, output_json):
+    """Fetch logs from a pod in a burner.
+
+    Examples:
+
+        gravi burner logs tank backend-xyz
+
+        gravi burner logs tank backend-xyz --tail 500
+
+        gravi burner logs tank backend-xyz -c backend
+    """
+    try:
+        mom_token = get_mom_token()
+        mom_url = get_mom_url()
+        client = MomClient(mom_url)
+
+        data = client.get_pod_logs(
+            burner_id=burner_id,
+            pod_name=pod_name,
+            access_token=mom_token,
+            container=container,
+            tail_lines=tail_lines,
+        )
+
+        if output_json:
+            click.echo(json.dumps(data))
+        else:
+            if data.get("truncated"):
+                click.echo(f"[Showing last {tail_lines} lines, logs truncated]", err=True)
+            # API returns 'lines' as array or 'logs' as string
+            logs = data.get("logs") or "\n".join(data.get("lines", []))
+            click.echo(logs)
+
+    except NotAuthenticatedError:
+        click.echo("Error: Please run 'gravi login' first", err=True)
+        sys.exit(1)
+    except APIError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@burner.command("restart")
+@click.argument("burner_id")
+@click.argument("deployment_name")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def burner_restart(burner_id, deployment_name, output_json):
+    """Restart a deployment in a burner.
+
+    Triggers a rolling restart of all pods in the deployment.
+
+    Examples:
+
+        gravi burner restart tank backend
+
+        gravi burner restart pump forecast
+    """
+    try:
+        mom_token = get_mom_token()
+        mom_url = get_mom_url()
+        client = MomClient(mom_url)
+
+        response = client.restart_deployment(burner_id, deployment_name, mom_token)
+
+        if output_json:
+            click.echo(json.dumps(response))
+        else:
+            click.echo(f"Restart initiated for '{deployment_name}' in burner '{burner_id}'")
+
+    except NotAuthenticatedError:
+        click.echo("Error: Please run 'gravi login' first", err=True)
+        sys.exit(1)
+    except APIError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
 if __name__ == "__main__":
     main()

{gravi_cli-0.2.2 → gravi_cli-0.2.4}/gravi_cli/client.py

@@ -359,3 +359,206 @@ class MomClient:
             json_data=json_data,
             auth_token=access_token
         )
+
+    def create_burner(
+        self,
+        access_token: str,
+        ttl_hours: int = 2,
+        sheet_id: str | None = None,
+        source_env: str | None = None,
+        seed_level: str = "barebone",
+        custom_name: str | None = None,
+        build: str = "dev",
+        simple_demand: bool = False,
+    ) -> dict:
+        """
+        Create a new burner instance.
+
+        Args:
+            access_token: Mom access token
+            ttl_hours: Time-to-live in hours (1-168)
+            sheet_id: Google Sheet ID for full seeding
+            source_env: Source environment to copy from
+            seed_level: Seeding level (none, barebone, full, copy)
+            custom_name: Custom name for the burner
+            build: Build to deploy (dev, test, rc, or SHA)
+            simple_demand: Use even demand distribution
+
+        Returns:
+            {
+                "operation_id": "...",
+                "burner_id": "tank",
+                "stream_url": "/burners/operations/stream?operation_id=...",
+                "message": "Burner creation initiated"
+            }
+        """
+        json_data = {
+            "ttl_hours": ttl_hours,
+            "seed_level": seed_level,
+            "build": build,
+            "simple_demand": simple_demand,
+        }
+        if sheet_id:
+            json_data["sheet_id"] = sheet_id
+        if source_env:
+            json_data["source_env"] = source_env
+        if custom_name:
+            json_data["custom_name"] = custom_name
+
+        return self._make_request(
+            "POST",
+            "burners/create",
+            json_data=json_data,
+            auth_token=access_token,
+        )
+
+    def delete_burner(self, burner_id: str, access_token: str) -> dict:
+        """
+        Delete a burner instance.
+
+        Args:
+            burner_id: Burner ID to delete (e.g., "tank")
+            access_token: Mom access token
+
+        Returns:
+            {
+                "operation_id": "...",
+                "burner_id": "tank",
+                "stream_url": "/burners/operations/stream?operation_id=...",
+                "message": "Burner deletion initiated"
+            }
+        """
+        return self._make_request(
+            "POST",
+            "burners/delete",
+            json_data={"burner_id": burner_id},
+            auth_token=access_token,
+        )
+
+    def get_burner(self, burner_id: str, access_token: str) -> dict:
+        """
+        Get details of a specific burner.
+
+        Args:
+            burner_id: Burner ID (e.g., "tank")
+            access_token: Mom access token
+
+        Returns:
+            Burner details including status, url, created_by, expires_at, etc.
+        """
+        return self._make_request(
+            "POST",
+            "burners/get",
+            json_data={"burner_id": burner_id},
+            auth_token=access_token,
+        )
+
+    def get_operation_status(self, operation_id: str, access_token: str) -> dict:
+        """
+        Get status of a burner operation.
+
+        Args:
+            operation_id: Operation ID
+            access_token: Mom access token
+
+        Returns:
+            {
+                "operation_id": "...",
+                "status": "pending|running|completed|failed",
+                "progress_percent": 0-100,
+                "current_step": "...",
+                "initiated_at": "...",
+                "completed_at": "...",
+                "error_message": "..."
+            }
+        """
+        return self._make_request(
+            "POST",
+            "burners/operations/get",
+            json_data={"operation_id": operation_id},
+            auth_token=access_token,
+        )
+
+    def list_burner_pods(self, burner_id: str, access_token: str) -> dict:
+        """
+        List all pods in a burner namespace, grouped by deployment.
+
+        Args:
+            burner_id: Burner ID (e.g., "tank")
+            access_token: Mom access token
+
+        Returns:
+            {
+                "pods": [...],
+                "deployments": [
+                    {"name": "backend", "desired_replicas": 1, "ready_replicas": 1, "pods": [...]},
+                    ...
+                ],
+                "namespace": "burner-tank"
+            }
+        """
+        return self._make_request(
+            "GET",
+            f"burners/{burner_id}/pods",
+            auth_token=access_token,
+        )
+
+    def get_pod_logs(
+        self,
+        burner_id: str,
+        pod_name: str,
+        access_token: str,
+        container: str | None = None,
+        tail_lines: int = 100,
+        since_seconds: int | None = None,
+    ) -> dict:
+        """
+        Fetch logs from a pod.
+
+        Args:
+            burner_id: Burner ID (e.g., "tank")
+            pod_name: Name of the pod
+            access_token: Mom access token
+            container: Container name (optional)
+            tail_lines: Number of lines from end (default 100)
+            since_seconds: Only fetch logs newer than this many seconds
+
+        Returns:
+            {
+                "pod_name": "...",
+                "container": "...",
+                "logs": "...",
+                "truncated": false
+            }
+        """
+        # Build query params
+        params = [f"tail_lines={tail_lines}"]
+        if container:
+            params.append(f"container={container}")
+        if since_seconds:
+            params.append(f"since_seconds={since_seconds}")
+
+        query_string = "&".join(params)
+        return self._make_request(
+            "GET",
+            f"burners/{burner_id}/pods/{pod_name}/logs?{query_string}",
+            auth_token=access_token,
+        )
+
+    def restart_deployment(self, burner_id: str, deployment_name: str, access_token: str) -> dict:
+        """
+        Restart all pods in a deployment.
+
+        Args:
+            burner_id: Burner ID (e.g., "tank")
+            deployment_name: Name of the deployment to restart
+            access_token: Mom access token
+
+        Returns:
+            {"message": "Deployment backend restart initiated"}
+        """
+        return self._make_request(
+            "POST",
+            f"burners/{burner_id}/deployments/{deployment_name}/restart",
+            auth_token=access_token,
+        )

{gravi_cli-0.2.2 → gravi_cli-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gravi-cli"
-version = "0.2.2"
+version = "0.2.4"
 description = "CLI tool for Gravitate infrastructure management"
 readme = "README.md"
 requires-python = ">=3.10"