vantage-cli 0.1.1__py3-none-any.whl

vantage_cli/cache.py

@@ -0,0 +1,143 @@
+"""Token caching functionality for the Vantage CLI."""
+
+from __future__ import annotations
+
+import inspect
+from functools import wraps
+from pathlib import Path
+
+from loguru import logger
+
+from vantage_cli.constants import USER_TOKEN_CACHE_DIR
+from vantage_cli.exceptions import Abort
+from vantage_cli.schemas import TokenSet
+
+
+def init_cache(cache_dir: Path) -> None:
+    """Initialize cache directory."""
+    try:
+        USER_TOKEN_CACHE_DIR.mkdir(exist_ok=True, parents=True)
+        token_dir = USER_TOKEN_CACHE_DIR / "token"
+        token_dir.mkdir(exist_ok=True)
+        info_file = USER_TOKEN_CACHE_DIR / "info.txt"
+        info_file.write_text("This directory is used by Vantage CLI for its cache.")
+    except (PermissionError, OSError, FileNotFoundError) as e:
+        raise Abort(
+            f"""
+            Cache directory {USER_TOKEN_CACHE_DIR} doesn't exist, is not writable, or could not be created.
+            Error: {e}
+
+            Please check your home directory permissions and try again.
+            """,
+            subject="Non-writable cache dir",
+            log_message="Non-writable cache dir",
+        )
+
+
+def with_cache(func):
+    """Initialize cache before function execution."""
+    if inspect.iscoroutinefunction(func):
+
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            try:
+                USER_TOKEN_CACHE_DIR.mkdir(exist_ok=True, parents=True)
+                token_dir = USER_TOKEN_CACHE_DIR / "token"
+                token_dir.mkdir(exist_ok=True)
+                info_file = USER_TOKEN_CACHE_DIR / "info.txt"
+                info_file.write_text("This directory is used by Vantage CLI for its cache.")
+            except (PermissionError, OSError, FileNotFoundError) as e:
+                raise Abort(
+                    f"""
+                    Cache directory {USER_TOKEN_CACHE_DIR} doesn't exist, is not writable, or could not be created.
+                    Error: {e}
+
+                    Please check your home directory permissions and try again.
+                    """,
+                    subject="Non-writable cache dir",
+                    log_message=f"Non-writable cache dir: {e}",
+                )
+            return await func(*args, **kwargs)
+
+        return async_wrapper
+    else:
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                USER_TOKEN_CACHE_DIR.mkdir(exist_ok=True, parents=True)
+                token_dir = USER_TOKEN_CACHE_DIR / "token"
+                token_dir.mkdir(exist_ok=True)
+                info_file = USER_TOKEN_CACHE_DIR / "info.txt"
+                info_file.write_text("This directory is used by Vantage CLI for its cache.")
+            except (PermissionError, OSError, FileNotFoundError) as e:
+                raise Abort(
+                    f"""
+                    Cache directory {USER_TOKEN_CACHE_DIR} doesn't exist, is not writable, or could not be created.
+                    Error: {e}
+
+                    Please check your home directory permissions and try again.
+                    """,
+                    subject="Non-writable cache dir",
+                    log_message="Non-writable cache dir",
+                )
+            return func(*args, **kwargs)
+
+        return wrapper
+
+
+def _get_token_paths(profile: str) -> tuple[Path, Path]:
+    token_dir = USER_TOKEN_CACHE_DIR / profile
+    access_token_path: Path = token_dir / "access.token"
+    refresh_token_path: Path = token_dir / "refresh.token"
+    return (access_token_path, refresh_token_path)
+
+
+def load_tokens_from_cache(profile: str) -> TokenSet:
+    """Load access token and refresh token from the cache."""
+    (access_token_path, refresh_token_path) = _get_token_paths(profile)
+
+    Abort.require_condition(
+        access_token_path.exists(),
+        "Please login with your auth token first using the `vantage login` command",
+        raise_kwargs={"subject": "You need to login"},
+    )
+
+    logger.debug("Retrieving access token from cache")
+    token_set: TokenSet = TokenSet(access_token=access_token_path.read_text())
+
+    if refresh_token_path.exists():
+        logger.debug("Retrieving refresh token from cache")
+        token_set.refresh_token = refresh_token_path.read_text()
+
+    return token_set
+
+
+def save_tokens_to_cache(profile: str, token_set: TokenSet):
+    """Save tokens from a token_set to the cache."""
+    (access_token_path, refresh_token_path) = _get_token_paths(profile)
+    # make sure the parent directory exists
+    access_token_path.parent.mkdir(parents=True, exist_ok=True)
+
+    logger.debug(f"Caching access token at {access_token_path}")
+    access_token_path.write_text(token_set.access_token)
+    access_token_path.chmod(0o600)
+
+    if token_set.refresh_token is not None:
+        logger.debug(f"Caching refresh token at {refresh_token_path}")
+        refresh_token_path.write_text(token_set.refresh_token)
+        refresh_token_path.chmod(0o600)
+
+
+def clear_token_cache(profile: str):
+    """Clear the token cache."""
+    logger.debug("Clearing cached tokens")
+    (access_token_path, refresh_token_path) = _get_token_paths(profile)
+
+    logger.debug(f"Removing access token at {access_token_path}")
+    if access_token_path.exists():
+        access_token_path.unlink()
+
+    logger.debug(f"Removing refresh token at {refresh_token_path}")
+    if refresh_token_path.exists():
+        refresh_token_path.unlink()

vantage_cli/client.py

@@ -0,0 +1,84 @@
+"""Simple async HTTP client for OAuth token operations."""
+
+from __future__ import annotations
+
+from functools import wraps
+from typing import Any, Callable, TypeVar
+
+import httpx
+import pydantic
+import typer
+from loguru import logger
+
+from vantage_cli.exceptions import Abort
+
+
+def attach_client(func: Callable) -> Callable:
+    """Create async HTTP client for OAuth operations."""
+
+    @wraps(func)
+    async def wrapper(ctx: typer.Context, *args: Any, **kwargs: Any) -> Any:
+        if ctx.obj.settings is None:
+            raise Abort(
+                "Cannot attach client before settings!",
+                subject="Configuration Error",
+                log_message="Settings not configured before client attachment",
+            )
+
+        logger.debug("Creating async HTTP client for OAuth operations")
+        async with httpx.AsyncClient(
+            base_url=ctx.obj.settings.oidc_base_url,
+            headers={"content-type": "application/x-www-form-urlencoded"},
+        ) as client:
+            ctx.obj.client = client
+            return await func(ctx, *args, **kwargs)
+
+    return wrapper
+
+
+ResponseModel = TypeVar("ResponseModel", bound=pydantic.BaseModel)
+
+
+async def make_oauth_request(
+    client: httpx.AsyncClient,
+    url_path: str,
+    data: dict[str, Any],
+    response_model_cls: type[ResponseModel],
+    abort_message: str = "OAuth request failed",
+    abort_subject: str = "AUTHENTICATION ERROR",
+) -> ResponseModel:
+    """Make an async OAuth token request.
+
+    Simplified version focused only on OAuth POST requests with form data.
+    """
+    logger.debug(f"Making OAuth request to {url_path}")
+
+    try:
+        response = await client.post(url_path, data=data)
+        response.raise_for_status()
+
+        response_data = response.json()
+        logger.debug(f"OAuth response received: {response_data}")
+
+        return response_model_cls(**response_data)
+
+    except httpx.HTTPStatusError as e:
+        logger.error(
+            f"OAuth request failed with status {e.response.status_code}: {e.response.text}"
+        )
+        if abort_message == "IGNORE":
+            raise e
+        raise Abort(
+            f"{abort_message}: Received error response",
+            subject=abort_subject,
+            log_message=f"OAuth request failed: {e.response.status_code} - {e.response.text}",
+        )
+    except (httpx.RequestError, httpx.ConnectError, httpx.TimeoutException) as e:
+        logger.error(f"OAuth request failed: {e}")
+        if abort_message == "IGNORE":
+            raise e
+        raise Abort(
+            f"{abort_message}: Request failed",
+            subject=abort_subject,
+            log_message=f"OAuth request error: {e}",
+        )

vantage_cli/command_base.py

@@ -0,0 +1,63 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Base command utilities for consistent global option handling."""
+
+from typing import Optional
+
+import typer
+from typing_extensions import Annotated
+
+# Reusable type annotations for global options
+JsonOption = Annotated[bool, typer.Option("--json", "-j", help="Output in JSON format")]
+VerboseOption = Annotated[bool, typer.Option("--verbose", "-v", help="Enable verbose output")]
+
+
+class GlobalOptions:
+    """Helper class to manage global options consistently across commands."""
+
+    def __init__(self, ctx: typer.Context, local_json: bool = False, local_verbose: bool = False):
+        self.ctx = ctx
+        self.local_json = local_json
+        self.local_verbose = local_verbose
+
+    @property
+    def json_output(self) -> bool:
+        """Get effective JSON output setting."""
+        global_json = getattr(self.ctx.obj, "json_output", False) if self.ctx.obj else False
+        return self.local_json or global_json
+
+    @property
+    def verbose(self) -> bool:
+        """Get effective verbose setting."""
+        global_verbose = getattr(self.ctx.obj, "verbose", False) if self.ctx.obj else False
+        return self.local_verbose or global_verbose
+
+    @property
+    def profile(self) -> Optional[str]:
+        """Get the active profile."""
+        return getattr(self.ctx.obj, "profile", None) if self.ctx.obj else None
+
+
+def get_global_options(
+    ctx: typer.Context, json_output: bool = False, verbose: bool = False
+) -> GlobalOptions:
+    """Create GlobalOptions instance."""
+    return GlobalOptions(ctx, json_output, verbose)
+
+
+# Utility functions for individual options
+def get_effective_json_output(ctx: typer.Context, local_json: bool = False) -> bool:
+    """Get the effective JSON output setting with precedence: local > global > default."""
+    global_json = getattr(ctx.obj, "json_output", False) if ctx.obj else False
+    return local_json or global_json
+
+
+def get_effective_verbose(ctx: typer.Context, local_verbose: bool = False) -> bool:
+    """Get the effective verbose setting with precedence: local > global > default."""
+    global_verbose = getattr(ctx.obj, "verbose", False) if ctx.obj else False
+    return local_verbose or global_verbose
+
+
+def get_active_profile(ctx: typer.Context) -> Optional[str]:
+    """Get the active profile from context."""
+    return getattr(ctx.obj, "profile", None) if ctx.obj else None

vantage_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Vantage CLI command modules."""

vantage_cli/commands/clouds/__init__.py

@@ -0,0 +1,20 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Clouds management commands package."""
+
+import typer
+
+from .add import add_command
+from .delete import delete_command
+from .update import update_command
+
+clouds_app = typer.Typer(
+    name="clouds",
+    help="Manage cloud provider configurations and integrations for your Vantage infrastructure.",
+    no_args_is_help=True,
+)
+
+# Register all commands
+clouds_app.command("add")(add_command)
+clouds_app.command("delete")(delete_command)
+clouds_app.command("update")(update_command)

vantage_cli/commands/clouds/add.py

@@ -0,0 +1,81 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Add cloud command."""
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+import typer
+from typing_extensions import Annotated
+
+logger = logging.getLogger(__name__)
+
+
+def add_command(
+    ctx: typer.Context,
+    cloud_name: Annotated[str, typer.Argument(help="Name of the cloud to add")],
+    provider: Annotated[
+        str, typer.Option("--provider", "-p", help="Cloud provider (aws, gcp, azure, etc.)")
+    ],
+    region: Annotated[
+        Optional[str], typer.Option("--region", "-r", help="Default region for the cloud")
+    ] = None,
+    config_file: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--config-file",
+            help="Path to cloud configuration file",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+        ),
+    ] = None,
+    credentials_file: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--credentials-file",
+            help="Path to credentials file",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+        ),
+    ] = None,
+):
+    """Add a new cloud configuration."""
+    verbose = ctx.obj.get("verbose", False)
+    settings = ctx.obj.get("settings")
+
+    logger.info(f"Adding cloud configuration: {cloud_name}")
+
+    if verbose:
+        logger.debug(f"Provider: {provider}")
+        logger.debug(f"Region: {region}")
+        logger.debug(f"Config file: {config_file}")
+        logger.debug(f"Credentials file: {credentials_file}")
+        logger.debug(f"Settings: {settings}")
+
+    # TODO: Validate that cloud doesn't already exist
+
+    if config_file:
+        logger.info(f"Using config file: {config_file}")
+        typer.echo(f"Adding cloud '{cloud_name}' with config file: {config_file}")
+    else:
+        typer.echo(f"Adding cloud '{cloud_name}' with provider: {provider}")
+        if region:
+            typer.echo(f"Default region: {region}")
+
+    if credentials_file:
+        logger.info(f"Using credentials file: {credentials_file}")
+        typer.echo(f"Credentials file: {credentials_file}")
+
+    # TODO: Implement actual cloud configuration addition logic
+    # This would typically:
+    # 1. Validate the cloud configuration
+    # 2. Store the cloud config in the appropriate location
+    # 3. Update the supported clouds list
+
+    logger.info(f"Cloud {cloud_name} added successfully")
+    typer.echo(f"✅ Cloud '{cloud_name}' added successfully")

vantage_cli/commands/clouds/delete.py

@@ -0,0 +1,61 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Delete cloud command."""
+
+import logging
+
+import typer
+from typing_extensions import Annotated
+
+logger = logging.getLogger(__name__)
+
+
+def delete_command(
+    ctx: typer.Context,
+    cloud_name: Annotated[str, typer.Argument(help="Name of the cloud to delete")],
+    force: Annotated[
+        bool, typer.Option("--force", help="Force deletion without confirmation")
+    ] = False,
+    remove_credentials: Annotated[
+        bool, typer.Option("--remove-credentials", help="Also remove stored credentials")
+    ] = False,
+):
+    """Delete a cloud configuration."""
+    verbose = ctx.obj.get("verbose", False)
+    settings = ctx.obj.get("settings")
+
+    logger.info(f"Deleting cloud configuration: {cloud_name}")
+
+    if verbose:
+        logger.debug(f"Force: {force}")
+        logger.debug(f"Remove credentials: {remove_credentials}")
+        logger.debug(f"Settings: {settings}")
+
+    # TODO: Check if cloud exists
+    # TODO: Check if cloud is in use by any clusters
+
+    if not force:
+        warning_msg = f"Are you sure you want to delete cloud configuration '{cloud_name}'?"
+        if remove_credentials:
+            warning_msg += " This will also remove stored credentials."
+
+        confirm = typer.confirm(warning_msg)
+        if not confirm:
+            typer.echo("Operation cancelled.")
+            raise typer.Abort()
+
+    typer.echo(f"Deleting cloud configuration: {cloud_name}")
+
+    if remove_credentials:
+        typer.echo("Removing stored credentials...")
+        logger.info("Removing stored credentials")
+
+    # TODO: Implement actual cloud configuration deletion logic
+    # This would typically:
+    # 1. Remove cloud config from storage
+    # 2. Update the supported clouds list
+    # 3. Optionally remove credentials
+    # 4. Clean up any related files
+
+    logger.info(f"Cloud {cloud_name} deleted successfully")
+    typer.echo(f"✅ Cloud '{cloud_name}' deleted successfully")

vantage_cli/commands/clouds/render.py

@@ -0,0 +1,146 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Render helpers for cloud 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_clouds_table(
+    clouds: List[Dict[str, Any]],
+    title: str = "Cloud Accounts",
+    total_count: Optional[int] = None,
+    json_output: bool = False,
+) -> None:
+    """Render a list of cloud accounts in a Rich table format.
+
+    Args:
+        clouds: List of cloud account dictionaries
+        title: Title for the table
+        total_count: Total number of cloud accounts available
+        json_output: If True, output as JSON instead of a table
+    """
+    if json_output:
+        output = {"clouds": clouds, "total": total_count or len(clouds)}
+        print_json(data=output)
+        return
+
+    if not clouds:
+        console = Console()
+        console.print()
+        console.print(Panel("No cloud accounts found.", title="[yellow]No Results"))
+        console.print()
+        return
+
+    # Define cloud-specific styling
+    style_mapper = StyleMapper(
+        name="bold cyan", provider="blue", status="green", accountId="white", region="yellow"
+    )
+
+    # Create the table
+    table = Table(
+        title=title,
+        caption=f"Items: {len(clouds)}{f' of {total_count}' if total_count else ''}",
+        show_header=True,
+        header_style="bold white",
+    )
+
+    # Add columns based on cloud data structure
+    column_mapping = {
+        "name": "Name",
+        "provider": "Provider",
+        "status": "Status",
+        "accountId": "Account ID",
+        "region": "Region",
+    }
+
+    # Add columns that exist in the first cloud entry
+    if clouds:
+        first_cloud = clouds[0]
+        for key, display_name in column_mapping.items():
+            if key in first_cloud:
+                table.add_column(display_name, **style_mapper.map_style(key))
+
+    # Add rows
+    for cloud in clouds:
+        row_values = []
+        for key in column_mapping.keys():
+            if key in cloud:
+                value = cloud.get(key, "")
+                if value is None:
+                    value = ""
+                row_values.append(str(value))
+        if row_values:  # Only add row if we have values
+            table.add_row(*row_values)
+
+    # Print the table
+    console = Console()
+    console.print()
+    console.print(table)
+    console.print()
+
+
+def render_cloud_operation_result(
+    operation: str,
+    cloud_name: str,
+    success: bool = True,
+    details: Optional[Dict[str, Any]] = None,
+    json_output: bool = False,
+) -> None:
+    """Render the result of a cloud operation (add, update, delete).
+
+    Args:
+        operation: The operation performed (add, update, delete)
+        cloud_name: Name of the cloud account
+        success: Whether the operation was successful
+        details: Additional details about the operation
+        json_output: If True, output as JSON instead of a formatted view
+    """
+    if json_output:
+        result = {
+            "operation": operation,
+            "cloud_name": cloud_name,
+            "success": success,
+            "details": details or {},
+        }
+        print_json(data=result)
+        return
+
+    console = Console()
+    console.print()
+
+    status_icon = "✅" if success else "❌"
+    status_color = "green" if success else "red"
+    action_text = f"{operation.title()}d" if success else f"{operation.title()} Failed"
+
+    console.print(
+        Panel(
+            f"{status_icon} Cloud account '[bold cyan]{cloud_name}[/bold cyan]' {operation} {'successful' if success else 'failed'}!",
+            title=f"[{status_color}]{action_text}[/{status_color}]",
+            border_style=status_color,
+        )
+    )
+
+    if details and not json_output:
+        # Show additional details if provided
+        details_table = Table(
+            title="Operation Details", show_header=False, box=None, padding=(0, 1)
+        )
+        details_table.add_column("Field", style="bold blue", width=20)
+        details_table.add_column("Value", style="white")
+
+        for key, value in details.items():
+            if value is not None:
+                display_key = key.replace("_", " ").title()
+                details_table.add_row(display_key, str(value))
+
+        console.print()
+        console.print(details_table)
+
+    console.print()