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

llama_deploy/cli/commands/deployment.py

@@ -6,18 +6,24 @@ 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 ..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 +41,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(
@@ -89,13 +97,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,12 +108,11 @@ 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")
@@ -139,22 +143,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 +169,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 +197,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 +230,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 +243,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 +270,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/config.py

@@ -13,7 +13,8 @@ class Profile:
 
     name: str
     api_url: str
-    active_project_id: str | None = None
+    project_id: str
+    api_key_auth_token: str | None = None
 
 
 class ConfigManager:
@@ -24,9 +25,16 @@ class ConfigManager:
         self.db_path = self.config_dir / "profiles.db"
         self._ensure_config_dir()
         self._init_database()
+        self.default_control_plane_url = "https://api.llamacloud.com"
 
     def _get_config_dir(self) -> Path:
-        """Get the configuration directory path based on OS"""
+        """Get the configuration directory path based on OS.
+
+        Honors LLAMACTL_CONFIG_DIR when set. This helps tests isolate state.
+        """
+        override = os.environ.get("LLAMACTL_CONFIG_DIR")
+        if override:
+            return Path(override).expanduser()
         if os.name == "nt":  # Windows
             config_dir = Path(os.environ.get("APPDATA", "~")) / "llamactl"
         else:  # Unix-like (Linux, macOS)
@@ -44,18 +52,35 @@ class ConfigManager:
             cursor = conn.execute("PRAGMA table_info(profiles)")
             columns = [row[1] for row in cursor.fetchall()]
 
-            if "project_id" in columns and "active_project_id" not in columns:
-                # Migrate old schema to new schema
-                conn.execute("""
-                    ALTER TABLE profiles RENAME COLUMN project_id TO active_project_id
-                """)
+            # Migration: handle old active_project_id -> project_id and make it required
+            if "active_project_id" in columns and "project_id" not in columns:
+                # Delete any profiles that have no active_project_id since project_id is now required
+                conn.execute(
+                    "DELETE FROM profiles WHERE active_project_id IS NULL OR active_project_id = ''"
+                )
+
+                # Rename active_project_id to project_id
+                # Note: SQLite doesn't allow changing column constraints easily, but we enforce
+                # the NOT NULL constraint in our application code and new table creation
+                conn.execute(
+                    "ALTER TABLE profiles RENAME COLUMN active_project_id TO project_id"
+                )
 
-            # Create tables with new schema
+                # Add api_key_auth_token column if not already present
+                mig_cursor = conn.execute("PRAGMA table_info(profiles)")
+                mig_columns = [row[1] for row in mig_cursor.fetchall()]
+                if "api_key_auth_token" not in mig_columns:
+                    conn.execute(
+                        "ALTER TABLE profiles ADD COLUMN api_key_auth_token TEXT"
+                    )
+
+            # Create tables with new schema (this will only create if they don't exist)
             conn.execute("""
                 CREATE TABLE IF NOT EXISTS profiles (
                     name TEXT PRIMARY KEY,
                     api_url TEXT NOT NULL,
-                    active_project_id TEXT
+                    project_id TEXT NOT NULL,
+                    api_key_auth_token TEXT
                 )
             """)
 
@@ -69,18 +94,32 @@ class ConfigManager:
             conn.commit()
 
     def create_profile(
-        self, name: str, api_url: str, active_project_id: str | None = None
+        self,
+        name: str,
+        api_url: str,
+        project_id: str,
+        api_key_auth_token: str | None = None,
     ) -> Profile:
         """Create a new profile"""
+        if not project_id.strip():
+            raise ValueError("Project ID is required")
         profile = Profile(
-            name=name, api_url=api_url, active_project_id=active_project_id
+            name=name,
+            api_url=api_url,
+            project_id=project_id,
+            api_key_auth_token=api_key_auth_token,
         )
 
         with sqlite3.connect(self.db_path) as conn:
             try:
                 conn.execute(
-                    "INSERT INTO profiles (name, api_url, active_project_id) VALUES (?, ?, ?)",
-                    (profile.name, profile.api_url, profile.active_project_id),
+                    "INSERT INTO profiles (name, api_url, project_id, api_key_auth_token) VALUES (?, ?, ?, ?)",
+                    (
+                        profile.name,
+                        profile.api_url,
+                        profile.project_id,
+                        profile.api_key_auth_token,
+                    ),
                 )
                 conn.commit()
             except sqlite3.IntegrityError:
@@ -92,12 +131,17 @@ class ConfigManager:
         """Get a profile by name"""
         with sqlite3.connect(self.db_path) as conn:
             cursor = conn.execute(
-                "SELECT name, api_url, active_project_id FROM profiles WHERE name = ?",
+                "SELECT name, api_url, project_id, api_key_auth_token FROM profiles WHERE name = ?",
                 (name,),
             )
             row = cursor.fetchone()
             if row:
-                return Profile(name=row[0], api_url=row[1], active_project_id=row[2])
+                return Profile(
+                    name=row[0],
+                    api_url=row[1],
+                    project_id=row[2],
+                    api_key_auth_token=row[3],
+                )
         return None
 
     def list_profiles(self) -> List[Profile]:
@@ -105,11 +149,16 @@ class ConfigManager:
         profiles = []
         with sqlite3.connect(self.db_path) as conn:
             cursor = conn.execute(
-                "SELECT name, api_url, active_project_id FROM profiles ORDER BY name"
+                "SELECT name, api_url, project_id, api_key_auth_token FROM profiles ORDER BY name"
             )
             for row in cursor.fetchall():
                 profiles.append(
-                    Profile(name=row[0], api_url=row[1], active_project_id=row[2])
+                    Profile(
+                        name=row[0],
+                        api_url=row[1],
+                        project_id=row[2],
+                        api_key_auth_token=row[3],
+                    )
                 )
         return profiles
 
@@ -151,22 +200,41 @@ class ConfigManager:
         current_name = self.get_current_profile_name()
         if current_name:
             return self.get_profile(current_name)
+        profiles = self.list_profiles()
+        if len(profiles) == 1:
+            return profiles[0]
         return None
 
-    def set_active_project(self, profile_name: str, project_id: str | None) -> bool:
-        """Set the active project for a profile. Returns True if profile exists."""
+    def set_project(self, profile_name: str, project_id: str) -> bool:
+        """Set the project for a profile. Returns True if profile exists."""
         with sqlite3.connect(self.db_path) as conn:
             cursor = conn.execute(
-                "UPDATE profiles SET active_project_id = ? WHERE name = ?",
+                "UPDATE profiles SET project_id = ? WHERE name = ?",
                 (project_id, profile_name),
             )
             conn.commit()
             return cursor.rowcount > 0
 
-    def get_active_project(self, profile_name: str) -> str | None:
-        """Get the active project for a profile"""
+    def set_default_control_plane_url(self, url: str) -> None:
+        """Set the default control plane URL for the current session"""
+        self.default_control_plane_url = url
+
+    def get_project(self, profile_name: str) -> str | None:
+        """Get the project for a profile"""
         profile = self.get_profile(profile_name)
-        return profile.active_project_id if profile else None
+        return profile.project_id if profile else None
+
+    def set_api_key_auth_token(
+        self, profile_name: str, api_key_auth_token: str | None
+    ) -> bool:
+        """Set the API key auth token for a profile. Returns True if profile exists."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "UPDATE profiles SET api_key_auth_token = ? WHERE name = ?",
+                (api_key_auth_token, profile_name),
+            )
+            conn.commit()
+            return cursor.rowcount > 0
 
 
 # Global config manager instance

llama_deploy/cli/interactive_prompts/session_utils.py

@@ -0,0 +1,37 @@
+"""Utilities for detecting and handling interactive CLI sessions."""
+
+import functools
+import os
+import sys
+
+
+@functools.cache
+def is_interactive_session() -> bool:
+    """
+    Detect if the current CLI session is interactive.
+
+    Returns True if the session is interactive (user can be prompted),
+    False if it's non-interactive (e.g., CI/CD, scripted environment).
+
+    This function checks multiple indicators:
+    - Whether stdin/stdout are connected to a TTY
+    - Explicit non-interactive environment variables
+
+    Examples:
+        >>> if is_interactive_session():
+        ...     user_input = questionary.text("Enter value:").ask()
+        ... else:
+        ...     raise click.ClickException("Value required in non-interactive mode")
+    """
+
+    # Check if stdin and stdout are TTYs
+    # This is the most reliable indicator for interactive sessions
+    if not (sys.stdin.isatty() and sys.stdout.isatty()):
+        return False
+
+    # Additional check for TERM environment variable
+    # Some environments set TERM=dumb for non-interactive sessions
+    if os.environ.get("TERM") == "dumb":
+        return False
+
+    return True

llama_deploy/cli/interactive_prompts/utils.py

@@ -4,56 +4,26 @@ import questionary
 from rich import print as rprint
 from rich.console import Console
 
-from ..client import get_project_client as get_client
 from ..config import config_manager
+from .session_utils import is_interactive_session
 
 console = Console()
 
 
-def select_deployment(deployment_id: str | None = None) -> str | None:
-    """
-    Select a deployment interactively if ID not provided.
-    Returns the selected deployment ID or None if cancelled.
-    """
-    if deployment_id:
-        return deployment_id
-
-    try:
-        client = get_client()
-        deployments = 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
-
-
 def select_profile(profile_name: str | None = None) -> str | None:
     """
     Select a profile interactively if name not provided.
     Returns the selected profile name or None if cancelled.
+
+    In non-interactive sessions, returns None if profile_name is not provided.
     """
     if profile_name:
         return profile_name
 
+    # Don't attempt interactive selection in non-interactive sessions
+    if not is_interactive_session():
+        return None
+
     try:
         profiles = config_manager.list_profiles()
 
@@ -80,5 +50,10 @@ def select_profile(profile_name: str | None = None) -> str | None:
 def confirm_action(message: str, default: bool = False) -> bool:
     """
     Ask for confirmation with a consistent interface.
+
+    In non-interactive sessions, returns the default value without prompting.
     """
+    if not is_interactive_session():
+        return default
+
     return questionary.confirm(message, default=default).ask() or False

llama_deploy/cli/options.py

@@ -2,6 +2,10 @@ import logging
 from typing import Callable, ParamSpec, TypeVar
 
 import click
+from llama_deploy.cli.config import config_manager
+from llama_deploy.cli.interactive_prompts.session_utils import is_interactive_session
+
+from .debug import setup_file_logging
 
 P = ParamSpec("P")
 R = TypeVar("R")
@@ -9,7 +13,6 @@ R = TypeVar("R")
 
 def global_options(f: Callable[P, R]) -> Callable[P, R]:
     """Common decorator to add global options to command groups"""
-    from .debug import setup_file_logging
 
     def debug_callback(ctx: click.Context, param: click.Parameter, value: str) -> str:
         if value:
@@ -27,3 +30,23 @@ def global_options(f: Callable[P, R]) -> Callable[P, R]:
         is_eager=True,
         hidden=True,
     )(f)
+
+
+def control_plane_url_callback(
+    ctx: click.Context, param: click.Parameter, value: str
+) -> str:
+    if value:
+        config_manager.set_default_control_plane_url(value)
+    return value
+
+
+def interactive_option(f: Callable[P, R]) -> Callable[P, R]:
+    """Add an interactive option to the command"""
+
+    default = is_interactive_session()
+    return click.option(
+        "--interactive/--no-interactive",
+        help="Run in interactive mode. If not provided, will default to the current session's interactive state.",
+        is_flag=True,
+        default=default,
+    )(f)

llama_deploy/cli/platform_client.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+import httpx
+from pydantic import BaseModel, TypeAdapter
+
+
+class PlatformClient:
+    def __init__(self, auth_token: str, platform_url: str):
+        self.auth_token = auth_token
+        self.platform_url = platform_url
+        self.client = httpx.AsyncClient(base_url=platform_url)
+
+    async def list_projects(self) -> list[Project]:
+        response = await self.client.get("/api/v1/projects")
+        response.raise_for_status()
+        return ProjectList.validate_python(response.json())
+
+    async def list_organizations(self) -> list[Organization]:
+        response = await self.client.get("/api/v1/organizations")
+        response.raise_for_status()
+        return OrganizationList.validate_python(response.json())
+
+    async def validate_auth_token(self) -> bool:
+        response = await self.client.get("/api/v1/organizations/default")
+        try:
+            response.raise_for_status()
+            return True
+        except httpx.HTTPStatusError:
+            if response.status_code == 401:
+                return False
+            raise
+
+
+class Organization(BaseModel):
+    id: str
+    name: str
+    created_at: datetime
+    updated_at: datetime
+
+
+class Project(BaseModel):
+    id: str
+    name: str
+    organization_id: str
+    created_at: datetime
+    updated_at: datetime
+
+
+OrganizationList = TypeAdapter(list[Organization])
+ProjectList = TypeAdapter(list[Project])