vantage-cli 0.1.1__py3-none-any.whl

vantage_cli/commands/clusters/render.py

@@ -0,0 +1,233 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Render helpers for cluster command output formatting."""
+
+from typing import Any, Dict, List, Optional
+
+from rich import print_json
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from vantage_cli.render import StyleMapper
+
+
+def render_clusters_table(
+    clusters: List[Dict[str, Any]],
+    title: str = "Clusters List",
+    total_count: Optional[int] = None,
+    json_output: bool = False,
+) -> None:
+    """Render a list of clusters in a Rich table format.
+
+    Args:
+        clusters: List of cluster dictionaries
+        title: Title for the table
+        total_count: Total number of clusters available
+        json_output: If True, output as JSON instead of a table
+    """
+    if json_output:
+        # Output as JSON with Rich formatting
+        output = {"clusters": clusters, "total": total_count or len(clusters)}
+        print_json(data=output)
+        return
+
+    if not clusters:
+        console = Console()
+        console.print()
+        console.print(Panel("No clusters found.", title="[yellow]No Results"))
+        console.print()
+        return
+
+    # Define cluster-specific styling
+    style_mapper = StyleMapper(
+        name="bold cyan",
+        status="green",
+        provider="blue",
+        ownerEmail="yellow",
+        clientId="white",
+        description="dim white",
+    )
+
+    # Create the table
+    table = Table(
+        title=title,
+        caption=f"Items: {len(clusters)}{f' of {total_count}' if total_count else ''}",
+        show_header=True,
+        header_style="bold white",
+    )
+
+    # Add columns based on the first cluster's keys
+    first_cluster = clusters[0]
+
+    # Define column order and display names
+    column_mapping = {
+        "name": "Name",
+        "status": "Status",
+        "provider": "Provider",
+        "ownerEmail": "Owner Email",
+        "clientId": "Client ID",
+        "description": "Description",
+    }
+
+    # Add columns in the specified order
+    for key, display_name in column_mapping.items():
+        if key in first_cluster:
+            table.add_column(display_name, **style_mapper.map_style(key))
+
+    # Add rows
+    for cluster in clusters:
+        row_values = []
+        for key in column_mapping.keys():
+            if key in cluster:
+                value = cluster.get(key, "")
+                # Handle None values and long descriptions
+                if value is None:
+                    value = ""
+                elif key == "description" and isinstance(value, str) and len(value) > 50:
+                    value = value[:47] + "..."
+                row_values.append(str(value))
+        table.add_row(*row_values)
+
+    # Print the table
+    console = Console()
+    console.print()
+    console.print(table)
+    console.print()
+
+
+def render_cluster_details(cluster: Dict[str, Any], json_output: bool = False) -> None:
+    """Render detailed information for a single cluster.
+
+    Args:
+        cluster: Cluster dictionary with details
+        json_output: If True, output as JSON instead of a formatted view
+    """
+    if json_output:
+        # Output as JSON with Rich formatting
+        print_json(data=cluster)
+        return
+
+    if not cluster:
+        console = Console()
+        console.print()
+        console.print(Panel("Cluster not found.", title="[red]Not Found"))
+        console.print()
+        return
+
+    console = Console()
+    cluster_name = cluster.get("name", "Unknown")
+
+    # Create a table matching the profile get command style
+    table = Table(
+        title=f"Cluster Details: {cluster_name}", show_header=True, header_style="bold white"
+    )
+
+    table.add_column("Property", style="bold cyan")
+    table.add_column("Value", style="white")
+
+    # Add basic cluster information
+    table.add_row("Name", cluster.get("name", "N/A"))
+    table.add_row("Status", cluster.get("status", "N/A"))
+    table.add_row("Provider", cluster.get("provider", "N/A"))
+    table.add_row("Owner Email", cluster.get("ownerEmail", "N/A"))
+    table.add_row("Client ID", cluster.get("clientId", "N/A"))
+
+    # Add client secret if available
+    client_secret = cluster.get("client_secret")
+    if client_secret:
+        table.add_row("Client Secret", f"[dim]{client_secret}[/dim]")
+    else:
+        table.add_row("Client Secret", "[dim]Not available[/dim]")
+
+    table.add_row("Description", cluster.get("description", "N/A"))
+
+    cloud_account_id = cluster.get("cloudAccountId")
+    table.add_row(
+        "Cloud Account ID", str(cloud_account_id) if cloud_account_id is not None else "None"
+    )
+
+    # Add creation parameters if available
+    creation_params = cluster.get("creationParameters", {})
+    if creation_params:
+        # Add a separator row
+        table.add_row("", "")  # Empty row for spacing
+        table.add_row("[bold]Creation Parameters[/bold]", "")
+
+        for key, value in creation_params.items():
+            if value is not None:
+                # Format key for display
+                display_key = key.replace("_", " ").title()
+                display_value = str(value) if not isinstance(value, dict) else "Complex Object"
+                table.add_row(f"  {display_key}", display_value)
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+def render_cluster_creation_result(cluster: Dict[str, Any], json_output: bool = False) -> None:
+    """Render the result of cluster creation.
+
+    Args:
+        cluster: Created cluster dictionary
+        json_output: If True, output as JSON instead of a formatted view
+    """
+    if json_output:
+        print_json(data=cluster)
+        return
+
+    console = Console()
+    console.print()
+    console.print(
+        Panel(
+            f"✅ Cluster '[bold cyan]{cluster.get('name', 'Unknown')}[/bold cyan]' created successfully!",
+            title="[green]Cluster Created[/green]",
+            border_style="green",
+        )
+    )
+
+    # Show basic details
+    render_cluster_details(cluster, json_output=False)
+
+
+def render_cluster_deletion_result(
+    cluster_name: str, success: bool = True, json_output: bool = False
+) -> None:
+    """Render the result of cluster deletion.
+
+    Args:
+        cluster_name: Name of the deleted cluster
+        success: Whether deletion was successful
+        json_output: If True, output as JSON instead of a formatted view
+    """
+    if json_output:
+        result = {
+            "cluster_name": cluster_name,
+            "deleted": success,
+            "message": f"Cluster '{cluster_name}' {'deleted' if success else 'deletion failed'}",
+        }
+        print_json(data=result)
+        return
+
+    console = Console()
+    console.print()
+
+    if success:
+        console.print(
+            Panel(
+                f"✅ Cluster '[bold cyan]{cluster_name}[/bold cyan]' deleted successfully!",
+                title="[green]Cluster Deleted[/green]",
+                border_style="green",
+            )
+        )
+    else:
+        console.print(
+            Panel(
+                f"❌ Failed to delete cluster '[bold cyan]{cluster_name}[/bold cyan]'",
+                title="[red]Deletion Failed[/red]",
+                border_style="red",
+            )
+        )
+
+    console.print()

vantage_cli/commands/clusters/schema.py

@@ -0,0 +1,31 @@
+"""Schema definitions for cluster commands."""
+
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel
+
+
+class VantageClusterContext(BaseModel):
+    """Vantage cluster context for generating juju configuration."""
+
+    client_id: str
+    client_secret: str
+    oidc_domain: str
+    oidc_base_url: str
+    base_api_url: str
+    tunnel_api_url: str
+    jupyterhub_token: str
+
+
+class ClusterDetailSchema(BaseModel):
+    """Schema for detailed cluster information."""
+
+    name: str
+    status: str
+    client_id: str
+    client_secret: Optional[str] = None
+    description: str
+    owner_mail: str
+    provider: str
+    cloud_account_id: Optional[str] = None
+    creation_parameters: Dict[str, Any]

vantage_cli/commands/clusters/utils.py

@@ -0,0 +1,248 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Shared utilities for cluster commands."""
+
+import importlib
+import logging
+import textwrap
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import httpx
+import typer
+from loguru import logger
+
+from vantage_cli.auth import extract_persona
+from vantage_cli.config import Settings
+from vantage_cli.exceptions import Abort
+from vantage_cli.gql_client import create_async_graphql_client
+
+
+def get_available_apps() -> Dict[str, Dict[str, Any]]:
+    """Dynamically discover available deployment apps."""
+    apps: Dict[str, Dict[str, Any]] = {}
+
+    # Register the apps maintained with the vantage cli
+    apps_dir = Path(__file__).parent.parent.parent / "apps"
+
+    if not apps_dir.exists():
+        logging.warning(f"Apps directory not found: {apps_dir}")
+        return apps
+
+    # Scan each app directory
+    for app_path in apps_dir.iterdir():
+        if app_path.is_dir() and not app_path.name.startswith("__"):
+            app_name = app_path.name
+            app_module_path = app_path / "app.py"
+
+            if app_module_path.exists():
+                # Convert directory name to the command name (e.g., "juju_localhost" -> "juju-localhost")
+                command_name = app_name.replace("_", "-")
+
+                try:
+                    # Dynamically import the app module
+                    app_module = importlib.import_module(f"vantage_cli.apps.{app_name}.app")
+
+                    # Check if deploy function exists
+                    if hasattr(app_module, "deploy"):
+                        deploy_function = getattr(app_module, "deploy")
+                        # Use command_name (with hyphens) as key so CLI can find it
+                        apps[command_name] = {
+                            "module": app_module,
+                            "deploy_function": deploy_function,
+                        }
+                except (ImportError, AttributeError, ModuleNotFoundError) as e:
+                    logger.warning(f"Failed to import app '{app_name}': {e}")
+                except Exception as e:
+                    logger.error(f"Unexpected error importing app '{app_name}': {e}")
+                    logger.debug(f"Full traceback for {app_name}", exc_info=True)
+
+    return apps
+
+
+def get_cloud_choices() -> list[str]:
+    """Get the list of supported clouds from settings."""
+    settings = Settings()
+    return settings.supported_clouds
+
+
+def get_app_choices() -> list[str]:
+    """Get the list of available deployment apps."""
+    try:
+        apps = get_available_apps()
+        return list(apps.keys())
+    except Exception as e:
+        logger.warning(f"Failed to get available apps: {e}")
+        return []
+
+
+async def get_cluster_client_secret(ctx: typer.Context, client_id: str) -> Optional[str]:
+    """Get the client secret for the cluster from vantage-api using GraphQL client auth.
+
+    Args:
+        ctx: Typer context carrying settings/profile
+        client_id: The client ID of the cluster
+
+    Returns:
+        The client secret if found, None otherwise
+    """
+    try:
+        # Get user authentication using the same method as GraphQL client
+        persona = extract_persona(ctx.obj.profile)
+        access_token = persona.token_set.access_token
+
+        # Use vantage-api admin/management/clients endpoint
+        api_url = f"{ctx.obj.settings.api_base_url}/admin/management/clients"
+
+        headers = {"Authorization": f"Bearer {access_token}", "Content-Type": "application/json"}
+
+        async with httpx.AsyncClient() as client:
+            # First, search for the client by clientId
+            params = {"client_id": client_id}
+            logger.debug(f"Searching for client with ID: {client_id} at {api_url}")
+            response = await client.get(api_url, headers=headers, params=params)
+
+            if response.status_code != 200:
+                logger.error(
+                    f"Failed to query vantage-api clients: {response.status_code} - {response.text}"
+                )
+                return None
+
+            response_data = response.json()
+            clients = response_data.get("clients", [])
+
+            if not clients:
+                logger.warning(f"No client found with clientId: {client_id}")
+                return None
+
+            # Get the first matching client's internal ID
+            vantage_client = clients[0]
+            internal_id = vantage_client.get("id")
+
+            if not internal_id:
+                logger.error(f"No internal ID found for client: {client_id}")
+                return None
+
+            # Get the client secret using the internal ID
+            secret_url = f"{api_url}/{internal_id}"
+            logger.debug(f"Fetching client secret from: {secret_url}")
+            secret_response = await client.get(secret_url, headers=headers)
+
+            if secret_response.status_code != 200:
+                logger.error(
+                    f"Failed to get client secret: {secret_response.status_code} - {secret_response.text}"
+                )
+                return None
+
+            secret_data = secret_response.json()
+            logger.debug(f"Client secret response data: {secret_data}")
+            # Try both camelCase and snake_case field names
+            client_secret = secret_data.get("client_secret")
+
+            if client_secret:
+                logger.debug(f"Successfully retrieved client secret for {client_id}")
+            else:
+                logger.warning(f"Client secret not found in response for {client_id}")
+                logger.debug(f"Available keys in response: {list(secret_data.keys())}")
+
+            return client_secret
+
+    except Exception as e:
+        logger.error(f"Error retrieving client secret for {client_id}: {e}")
+        typer.Exit(code=1)
+
+
+async def get_cluster_by_name(ctx: typer.Context, cluster_name: str) -> Dict[str, Any] | None:
+    """Get cluster details by name from vantage-api using GraphQL client auth.
+
+    Args:
+        ctx: Typer context carrying settings/profile
+        cluster_name: The name of the cluster to retrieve
+
+    Returns:
+        The cluster data if found, None otherwise
+    """
+    # Ensure we have settings configured
+    if not ctx.obj or not ctx.obj.settings:
+        raise Abort(
+            "No settings configured. Please run 'vantage config set' first.",
+            subject="Configuration Required",
+            log_message="Settings not configured",
+        )
+
+    query = textwrap.dedent("""\
+        query getClusters($first: Int!) {
+            clusters(first: $first) {
+                edges {
+                    node {
+                        name
+                        status
+                        clientId
+                        description
+                        ownerEmail
+                        provider
+                        cloudAccountId
+                        creationParameters
+                    }
+                }
+            }
+        }
+        """)
+
+    variables = {"first": 100}  # Fetch up to 100 clusters
+
+    try:
+        # Create async GraphQL client
+        graphql_client = create_async_graphql_client(ctx.obj.settings, ctx.obj.profile)
+
+        # Execute the query
+        logger.debug(f"Executing cluster get query for: {cluster_name}")
+        response_data = await graphql_client.execute_async(query, variables)
+
+        # Extract cluster data
+        clusters_data = response_data.get("clusters", {})
+        clusters = [edge["node"] for edge in clusters_data.get("edges", [])]
+
+        # Filter clusters by name (case-insensitive)
+        matching_clusters = [
+            cluster
+            for cluster in clusters
+            if cluster.get("name", "").lower() == cluster_name.lower()
+        ]
+
+        if not matching_clusters:
+            raise Abort(
+                f"No cluster found with name '{cluster_name}'.",
+                subject="Cluster Not Found",
+                log_message=f"Cluster '{cluster_name}' not found",
+            )
+
+        # Get the first (and should be only) cluster
+        cluster = matching_clusters[0]
+
+        # Fetch client secret from API if clientId is available
+        client_id = cluster.get("clientId")
+        if client_id:
+            try:
+                client_secret = await get_cluster_client_secret(ctx, client_id)
+                cluster["client_secret"] = client_secret
+            except Exception as e:
+                logger.warning(
+                    f"Failed to retrieve client secret for cluster '{cluster_name}': {e}"
+                )
+                cluster["client_secret"] = None
+        else:
+            cluster["client_secret"] = None
+
+        return cluster
+
+    except Abort:
+        # Re-raise Abort exceptions as they contain user-friendly messages
+        raise
+    except (httpx.RequestError, ValueError, KeyError, AttributeError) as e:
+        logger.error(f"Unexpected error getting cluster '{cluster_name}': {e}")
+        raise Abort(
+            f"An unexpected error occurred while getting cluster '{cluster_name}'.",
+            subject="Unexpected Error",
+            log_message=f"Unexpected error: {e}",
+        )

vantage_cli/commands/profile/__init__.py

@@ -0,0 +1,30 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Profile management commands for Vantage CLI."""
+
+import typer
+from rich.console import Console
+
+from .crud import create_profile, delete_profile, get_profile, list_profiles, use_profile
+
+console = Console()
+
+# Create the profile app
+profile_app = typer.Typer(
+    name="profile",
+    help="Manage Vantage CLI profiles to work with different environments and configurations.",
+    invoke_without_command=True,
+    no_args_is_help=True,
+    context_settings={
+        "allow_extra_args": True,
+        "allow_interspersed_args": True,
+        "ignore_unknown_options": True,
+    },
+)
+
+# Register subcommands
+profile_app.command("create")(create_profile)
+profile_app.command("delete")(delete_profile)
+profile_app.command("get")(get_profile)
+profile_app.command("list")(list_profiles)
+profile_app.command("use")(use_profile)