llamactl 0.3.0a12__py3-none-any.whl → 0.3.0a14__py3-none-any.whl

llama_deploy/cli/commands/deployment.py

@@ -6,18 +6,25 @@ A deployment points the control plane at your Git repository and deployment file
 git ref, reads the config, and runs your app.
 """
 
+import asyncio
+
 import click
+import questionary
+from llama_deploy.cli.commands.auth import validate_authenticated_profile
 from llama_deploy.core.schema.deployments import DeploymentUpdate
 from rich import print as rprint
 from rich.table import Table
+from rich.text import Text
 
 from ..app import app, console
 from ..client import get_project_client
+from ..interactive_prompts.session_utils import (
+    is_interactive_session,
+)
 from ..interactive_prompts.utils import (
     confirm_action,
-    select_deployment,
 )
-from ..options import global_options
+from ..options import global_options, interactive_option
 from ..textual.deployment_form import create_deployment_form, edit_deployment_form
 from ..textual.deployment_monitor import monitor_deployment_screen
 
@@ -35,11 +42,13 @@ def deployments() -> None:
 # Deployments commands
 @deployments.command("list")
 @global_options
-def list_deployments() -> None:
+@interactive_option
+def list_deployments(interactive: bool) -> None:
     """List deployments for the configured project."""
+    validate_authenticated_profile(interactive)
     try:
         client = get_project_client()
-        deployments = client.list_deployments()
+        deployments = asyncio.run(client.list_deployments())
 
         if not deployments:
             rprint(
@@ -47,36 +56,23 @@ def list_deployments() -> None:
             )
             return
 
-        table = Table(title=f"Deployments for project {client.project_id}")
-        table.add_column("Name", style="cyan")
-        table.add_column("ID", style="yellow")
-        table.add_column("Status", style="green")
-        table.add_column("Repository", style="blue")
-        table.add_column("Deployment File", style="magenta")
-        table.add_column("Git Ref", style="white")
-        table.add_column("PAT", style="red")
-        table.add_column("Secrets", style="bright_green")
+        table = Table(show_edge=False, box=None, header_style="bold cornflower_blue")
+        table.add_column("Name")
+        table.add_column("Status", style="grey46")
+        table.add_column("Repository", style="grey46")
 
         for deployment in deployments:
-            name = deployment.name
-            deployment_id = deployment.id
+            name = deployment.id
             status = deployment.status
             repo_url = deployment.repo_url
-            deployment_file_path = deployment.deployment_file_path
-            git_ref = deployment.git_ref
-            has_pat = "✓" if deployment.has_personal_access_token else "-"
-            secret_names = deployment.secret_names
-            secrets_display = str(len(secret_names)) if secret_names else "-"
+            gh = "https://github.com/"
+            if repo_url.startswith(gh):
+                repo_url = "gh:" + repo_url.removeprefix(gh)
 
             table.add_row(
                 name,
-                deployment_id,
                 status,
                 repo_url,
-                deployment_file_path,
-                git_ref,
-                has_pat,
-                secrets_display,
             )
 
         console.print(table)
@@ -89,13 +85,10 @@ def list_deployments() -> None:
 @deployments.command("get")
 @global_options
 @click.argument("deployment_id", required=False)
-@click.option(
-    "--non-interactive",
-    is_flag=True,
-    help="Do not open a live monitor screen showing status and streaming logs",
-)
-def get_deployment(deployment_id: str | None, non_interactive: bool) -> None:
+@interactive_option
+def get_deployment(deployment_id: str | None, interactive: bool) -> None:
     """Get details of a specific deployment"""
+    validate_authenticated_profile(interactive)
     try:
         client = get_project_client()
 
@@ -103,32 +96,31 @@ def get_deployment(deployment_id: str | None, non_interactive: bool) -> None:
         if not deployment_id:
             rprint("[yellow]No deployment selected[/yellow]")
             return
-
-        if not non_interactive:
+        if interactive:
             monitor_deployment_screen(deployment_id)
             return
 
-        deployment = client.get_deployment(deployment_id)
+        deployment = asyncio.run(client.get_deployment(deployment_id))
 
-        table = Table(title=f"Deployment: {deployment.name}")
-        table.add_column("Property", style="cyan")
-        table.add_column("Value", style="green")
+        table = Table(show_edge=False, box=None, header_style="bold cornflower_blue")
+        table.add_column("Property", style="grey46", justify="right")
+        table.add_column("Value")
 
-        table.add_row("ID", deployment.id)
-        table.add_row("Project ID", deployment.project_id)
-        table.add_row("Status", deployment.status)
-        table.add_row("Repository", deployment.repo_url)
-        table.add_row("Deployment File", deployment.deployment_file_path)
-        table.add_row("Git Ref", deployment.git_ref)
-        table.add_row("Has PAT", str(deployment.has_personal_access_token))
+        table.add_row("ID", Text(deployment.id))
+        table.add_row("Project ID", Text(deployment.project_id))
+        table.add_row("Status", Text(deployment.status))
+        table.add_row("Repository", Text(deployment.repo_url))
+        table.add_row("Deployment File", Text(deployment.deployment_file_path))
+        table.add_row("Git Ref", Text(deployment.git_ref or "-"))
 
         apiserver_url = deployment.apiserver_url
-        if apiserver_url:
-            table.add_row("API Server URL", str(apiserver_url))
+        table.add_row(
+            "API Server URL",
+            Text(str(apiserver_url) if apiserver_url else "-"),
+        )
 
-        secret_names = deployment.secret_names
-        if secret_names:
-            table.add_row("Secrets", ", ".join(secret_names))
+        secret_names = deployment.secret_names or []
+        table.add_row("Secrets", Text("\n".join(secret_names), style="italic"))
 
         console.print(table)
 
@@ -139,22 +131,18 @@ def get_deployment(deployment_id: str | None, non_interactive: bool) -> None:
 
 @deployments.command("create")
 @global_options
-@click.option("--repo-url", help="HTTP(S) Git Repository URL")
-@click.option("--name", help="Deployment name")
-@click.option("--deployment-file-path", help="Path to deployment file")
-@click.option("--git-ref", help="Git reference (branch, tag, or commit)")
-@click.option(
-    "--personal-access-token", help="Git Personal Access Token (HTTP Basic Auth)"
-)
+@interactive_option
 def create_deployment(
-    repo_url: str | None,
-    name: str | None,
-    deployment_file_path: str | None,
-    git_ref: str | None,
-    personal_access_token: str | None,
+    interactive: bool,
 ) -> None:
     """Interactively create a new deployment"""
 
+    if not interactive:
+        raise click.ClickException(
+            "This command requires an interactive session. Run in a terminal or provide required arguments explicitly."
+        )
+    validate_authenticated_profile(interactive)
+
     # Use interactive creation
     deployment_form = create_deployment_form()
     if deployment_form is None:
@@ -169,23 +157,24 @@ def create_deployment(
 @deployments.command("delete")
 @global_options
 @click.argument("deployment_id", required=False)
-@click.option("--confirm", is_flag=True, help="Skip confirmation prompt")
-def delete_deployment(deployment_id: str | None, confirm: bool) -> None:
+@interactive_option
+def delete_deployment(deployment_id: str | None, interactive: bool) -> None:
     """Delete a deployment"""
+    validate_authenticated_profile(interactive)
     try:
         client = get_project_client()
 
-        deployment_id = select_deployment(deployment_id)
+        deployment_id = select_deployment(deployment_id, interactive=interactive)
         if not deployment_id:
             rprint("[yellow]No deployment selected[/yellow]")
             return
 
-        if not confirm:
+        if interactive:
             if not confirm_action(f"Delete deployment '{deployment_id}'?"):
                 rprint("[yellow]Cancelled[/yellow]")
                 return
 
-        client.delete_deployment(deployment_id)
+        asyncio.run(client.delete_deployment(deployment_id))
         rprint(f"[green]Deleted deployment: {deployment_id}[/green]")
 
     except Exception as e:
@@ -196,18 +185,20 @@ def delete_deployment(deployment_id: str | None, confirm: bool) -> None:
 @deployments.command("edit")
 @global_options
 @click.argument("deployment_id", required=False)
-def edit_deployment(deployment_id: str | None) -> None:
+@interactive_option
+def edit_deployment(deployment_id: str | None, interactive: bool) -> None:
     """Interactively edit a deployment"""
+    validate_authenticated_profile(interactive)
     try:
         client = get_project_client()
 
-        deployment_id = select_deployment(deployment_id)
+        deployment_id = select_deployment(deployment_id, interactive=interactive)
         if not deployment_id:
             rprint("[yellow]No deployment selected[/yellow]")
             return
 
         # Get current deployment details
-        current_deployment = client.get_deployment(deployment_id)
+        current_deployment = asyncio.run(client.get_deployment(deployment_id))
 
         # Use the interactive edit form
         updated_deployment = edit_deployment_form(current_deployment)
@@ -227,8 +218,10 @@ def edit_deployment(deployment_id: str | None) -> None:
 @deployments.command("update")
 @global_options
 @click.argument("deployment_id", required=False)
-def refresh_deployment(deployment_id: str | None) -> None:
+@interactive_option
+def refresh_deployment(deployment_id: str | None, interactive: bool) -> None:
     """Update the deployment, pulling the latest code from it's branch"""
+    validate_authenticated_profile(interactive)
     try:
         client = get_project_client()
 
@@ -238,16 +231,18 @@ def refresh_deployment(deployment_id: str | None) -> None:
             return
 
         # Get current deployment details to show what we're refreshing
-        current_deployment = client.get_deployment(deployment_id)
+        current_deployment = asyncio.run(client.get_deployment(deployment_id))
         deployment_name = current_deployment.name
         old_git_sha = current_deployment.git_sha or ""
 
         # Create an empty update to force git SHA refresh with spinner
         with console.status(f"Refreshing {deployment_name}..."):
             deployment_update = DeploymentUpdate()
-            updated_deployment = client.update_deployment(
-                deployment_id,
-                deployment_update,
+            updated_deployment = asyncio.run(
+                client.update_deployment(
+                    deployment_id,
+                    deployment_update,
+                )
             )
 
         # Show the git SHA change with short SHAs
@@ -263,3 +258,47 @@ def refresh_deployment(deployment_id: str | None) -> None:
     except Exception as e:
         rprint(f"[red]Error: {e}[/red]")
         raise click.Abort()
+
+
+def select_deployment(
+    deployment_id: str | None = None, interactive: bool = is_interactive_session()
+) -> str | None:
+    """
+    Select a deployment interactively if ID not provided.
+    Returns the selected deployment ID or None if cancelled.
+
+    In non-interactive sessions, returns None if deployment_id is not provided.
+    """
+    if deployment_id:
+        return deployment_id
+
+    # Don't attempt interactive selection in non-interactive sessions
+    if not interactive:
+        return None
+
+    try:
+        client = get_project_client()
+        deployments = asyncio.run(client.list_deployments())
+
+        if not deployments:
+            rprint(
+                f"[yellow]No deployments found for project {client.project_id}[/yellow]"
+            )
+            return None
+
+        choices = []
+        for deployment in deployments:
+            name = deployment.name
+            deployment_id = deployment.id
+            status = deployment.status
+            choices.append(
+                questionary.Choice(
+                    title=f"{name} ({deployment_id}) - {status}", value=deployment_id
+                )
+            )
+
+        return questionary.select("Select deployment:", choices=choices).ask()
+
+    except Exception as e:
+        rprint(f"[red]Error loading deployments: {e}[/red]")
+        return None

llama_deploy/cli/commands/env.py

@@ -0,0 +1,206 @@
+from importlib import metadata as importlib_metadata
+
+import click
+import questionary
+from llama_deploy.cli.config.schema import Environment
+from packaging import version as packaging_version
+from rich import print as rprint
+from rich.table import Table
+from rich.text import Text
+
+from ..app import console
+from ..config.env_service import service
+from ..options import global_options, interactive_option
+from .auth import auth
+
+
+@auth.group(
+    name="env",
+    help="Manage environments (control plane API URLs)",
+    no_args_is_help=True,
+)
+@global_options
+def env_group() -> None:
+    pass
+
+
+@env_group.command("list")
+@global_options
+def list_environments_cmd() -> None:
+    try:
+        envs = service.list_environments()
+        current_env = service.get_current_environment()
+
+        if not envs:
+            rprint("[yellow]No environments found[/yellow]")
+            return
+
+        table = Table(show_edge=False, box=None, header_style="bold cornflower_blue")
+        table.add_column("  API URL")
+        table.add_column("Requires Auth")
+
+        for env in envs:
+            text = Text()
+            if env == current_env:
+                text.append("* ", style="magenta")
+            else:
+                text.append("  ")
+            text.append(env.api_url)
+            table.add_row(
+                text, Text("true" if env.requires_auth else "false", style="grey46")
+            )
+
+        console.print(table)
+    except Exception as e:
+        rprint(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+@env_group.command("add")
+@click.argument("api_url", required=False)
+@interactive_option
+@global_options
+def add_environment_cmd(api_url: str | None, interactive: bool) -> None:
+    try:
+        if not api_url:
+            if not interactive:
+                raise click.ClickException("API URL is required when not interactive")
+            current_env = service.get_current_environment()
+            entered = questionary.text(
+                "Enter control plane API URL", default=current_env.api_url
+            ).ask()
+            if not entered:
+                rprint("[yellow]No environment entered[/yellow]")
+                return
+            api_url = entered.strip()
+
+        api_url = api_url.rstrip("/")
+        env = service.probe_environment(api_url)
+        service.create_or_update_environment(env)
+        rprint(
+            f"[green]Added environment[/green] {env.api_url} (requires_auth={env.requires_auth}, min_llamactl_version={env.min_llamactl_version or '-'})."
+        )
+        _maybe_warn_min_version(env.min_llamactl_version)
+    except Exception as e:
+        rprint(f"[red]Failed to add environment: {e}[/red]")
+        raise click.Abort()
+
+
+@env_group.command("delete")
+@click.argument("api_url", required=False)
+@interactive_option
+@global_options
+def delete_environment_cmd(api_url: str | None, interactive: bool) -> None:
+    try:
+        if not api_url:
+            if not interactive:
+                raise click.ClickException("API URL is required when not interactive")
+            result = _select_environment(
+                service.list_environments(),
+                service.get_current_environment(),
+                "Select environment to delete",
+            )
+
+            if not result:
+                rprint("[yellow]No environment selected[/yellow]")
+                return
+            api_url = result.api_url
+
+        api_url = api_url.rstrip("/")
+        deleted = service.delete_environment(api_url)
+        if not deleted:
+            raise click.ClickException(f"Environment '{api_url}' not found")
+        rprint(
+            f"[green]Deleted environment[/green] {api_url} and all associated profiles"
+        )
+    except Exception as e:
+        rprint(f"[red]Failed to delete environment: {e}[/red]")
+        raise click.Abort()
+
+
+@env_group.command("switch")
+@click.argument("api_url", required=False)
+@interactive_option
+@global_options
+def switch_environment_cmd(api_url: str | None, interactive: bool) -> None:
+    try:
+        selected_url = api_url
+
+        if not selected_url and interactive:
+            result = _select_environment(
+                service.list_environments(),
+                service.get_current_environment(),
+                "Select environment",
+            )
+            if not result:
+                rprint("[yellow]No environment selected[/yellow]")
+                return
+            selected_url = result.api_url
+
+        if not selected_url:
+            if interactive:
+                rprint("[yellow]No environment selected[/yellow]")
+                return
+            raise click.ClickException("API URL is required when not interactive")
+
+        selected_url = selected_url.rstrip("/")
+
+        # Ensure environment exists and switch
+        env = service.switch_environment(selected_url)
+        try:
+            env = service.auto_update_env(env)
+        except Exception as e:
+            rprint(f"[yellow]Failed to resolve environment: {e}[/yellow]")
+            return
+        service.current_auth_service().select_any_profile()
+        rprint(f"[green]Switched to environment[/green] {env.api_url}")
+        _maybe_warn_min_version(env.min_llamactl_version)
+    except Exception as e:
+        rprint(f"[red]Failed to switch environment: {e}[/red]")
+        raise click.Abort()
+
+
+def _get_cli_version() -> str | None:
+    try:
+        return importlib_metadata.version("llamactl")
+    except Exception:
+        return None
+
+
+def _maybe_warn_min_version(min_required: str | None) -> None:
+    if not min_required:
+        return
+    current = _get_cli_version()
+    if not current:
+        return
+    try:
+        if packaging_version.parse(current) < packaging_version.parse(min_required):
+            rprint(
+                f"[yellow]Warning:[/yellow] This environment requires llamactl >= [bold]{min_required}[/bold], you have [bold]{current}[/bold]."
+            )
+    except Exception:
+        # If packaging is not available or parsing fails, skip strict comparison
+        pass
+
+
+def _select_environment(
+    envs: list[Environment],
+    current_env: Environment,
+    message: str = "Select environment",
+) -> Environment | None:
+    envs = service.list_environments()
+    current_env = service.get_current_environment()
+    if not envs:
+        raise click.ClickException(
+            "No environments found. This is a bug and shouldn't happen."
+        )
+    return questionary.select(
+        message,
+        choices=[
+            questionary.Choice(
+                title=f"{env.api_url} {'(current)' if env.api_url == current_env.api_url else ''}",
+                value=env,
+            )
+            for env in envs
+        ],
+    ).ask()