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

llama_deploy/cli/config/_config.py

@@ -0,0 +1,385 @@
+"""Configuration and profile management for llamactl"""
+
+import os
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+from .schema import DEFAULT_ENVIRONMENT, Auth, Environment
+
+
+def _to_auth(row: Any) -> Auth:
+    return Auth(
+        name=row[0],
+        api_url=row[1],
+        project_id=row[2],
+        api_key=row[3],
+    )
+
+
+def _to_environment(row: Any) -> Environment:
+    return Environment(
+        api_url=row[0],
+        requires_auth=bool(row[1]),
+        min_llamactl_version=row[2],
+    )
+
+
+class ConfigManager:
+    """Manages profiles and configuration using SQLite"""
+
+    def __init__(self):
+        self.config_dir = self._get_config_dir()
+        self.db_path = self.config_dir / "profiles.db"
+        self._ensure_config_dir()
+        self._init_database()
+
+    def _get_config_dir(self) -> Path:
+        """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)
+            config_dir = Path.home() / ".config" / "llamactl"
+        return config_dir.expanduser()
+
+    def _ensure_config_dir(self):
+        """Create configuration directory if it doesn't exist"""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def _init_database(self):
+        """Initialize SQLite database with required tables"""
+        with sqlite3.connect(self.db_path) as conn:
+            # Check if we need to migrate from old schema
+            cursor = conn.execute("PRAGMA table_info(profiles)")
+            columns = [row[1] for row in cursor.fetchall()]
+
+            # 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"
+                )
+
+                # Add api_key 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" not in mig_columns:
+                    conn.execute("ALTER TABLE profiles ADD COLUMN api_key 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,
+                    project_id TEXT NOT NULL,
+                    api_key TEXT
+                )
+            """)
+
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS settings (
+                    key TEXT PRIMARY KEY,
+                    value TEXT NOT NULL
+                )
+            """)
+
+            # Environments: first-class environments table
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS environments (
+                    api_url TEXT PRIMARY KEY,
+                    requires_auth INTEGER NOT NULL,
+                    min_llamactl_version TEXT
+                )
+                """
+            )
+
+            # Ensure there is a current environment setting. If missing, set to default.
+            setting_cursor = conn.execute(
+                "SELECT value FROM settings WHERE key = 'current_environment_api_url'"
+            )
+            setting_row = setting_cursor.fetchone()
+            if not setting_row:
+                conn.execute(
+                    "INSERT OR REPLACE INTO settings (key, value) VALUES ('current_environment_api_url', ?)",
+                    (DEFAULT_ENVIRONMENT.api_url,),
+                )
+
+            # Seed environments from existing profiles if environments is empty
+            env_count_cur = conn.execute("SELECT COUNT(*) FROM environments")
+            env_count = env_count_cur.fetchone()[0]
+            if env_count == 0:
+                # Insert distinct api_url values from profiles with requires_auth = 0 (False)
+                conn.execute(
+                    """
+                    INSERT OR IGNORE INTO environments (api_url, requires_auth)
+                    SELECT DISTINCT api_url, 0 FROM profiles
+                    """
+                )
+
+                # Also ensure the current environment exists as a row
+                cur_env_cursor = conn.execute(
+                    "SELECT value FROM settings WHERE key = 'current_environment_api_url'"
+                )
+                cur_env_row = cur_env_cursor.fetchone()
+                if cur_env_row:
+                    conn.execute(
+                        "INSERT OR IGNORE INTO environments (api_url, requires_auth, min_llamactl_version) VALUES (?, ?, ?)",
+                        (
+                            cur_env_row[0],
+                            1 if DEFAULT_ENVIRONMENT.requires_auth else 0,
+                            DEFAULT_ENVIRONMENT.min_llamactl_version,
+                        ),
+                    )
+
+            conn.commit()
+
+    def create_profile(
+        self,
+        name: str,
+        api_url: str,
+        project_id: str,
+        api_key: str | None = None,
+    ) -> Auth:
+        """Create a new auth profile"""
+        if not project_id.strip():
+            raise ValueError("Project ID is required")
+        profile = Auth(
+            name=name,
+            api_url=api_url,
+            project_id=project_id,
+            api_key=api_key,
+        )
+
+        with sqlite3.connect(self.db_path) as conn:
+            try:
+                conn.execute(
+                    "INSERT INTO profiles (name, api_url, project_id, api_key) VALUES (?, ?, ?, ?)",
+                    (
+                        profile.name,
+                        profile.api_url,
+                        profile.project_id,
+                        profile.api_key,
+                    ),
+                )
+                conn.commit()
+            except sqlite3.IntegrityError:
+                raise ValueError(f"Profile '{name}' already exists")
+
+        return profile
+
+    def get_profile(self, name: str, env_url: str) -> Auth | None:
+        """Get a profile by name"""
+        with sqlite3.connect(self.db_path) as conn:
+            row = conn.execute(
+                "SELECT name, api_url, project_id, api_key FROM profiles WHERE name = ? AND api_url = ?",
+                (name, env_url),
+            ).fetchone()
+            if row:
+                return _to_auth(row)
+        return None
+
+    def list_profiles(self, env_url: str) -> list[Auth]:
+        """List all profiles"""
+        with sqlite3.connect(self.db_path) as conn:
+            return [
+                _to_auth(row)
+                for row in conn.execute(
+                    "SELECT name, api_url, project_id, api_key FROM profiles WHERE api_url = ? ORDER BY name",
+                    (env_url,),
+                ).fetchall()
+            ]
+
+    def delete_profile(self, name: str, env_url: str) -> bool:
+        """Delete a profile by name. Returns True if deleted, False if not found."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "DELETE FROM profiles WHERE name = ? AND api_url = ?", (name, env_url)
+            )
+            conn.commit()
+
+            # If this was the active profile, clear it
+            if self.get_settings_current_profile_name() == name:
+                self.set_settings_current_profile(None)
+
+            return cursor.rowcount > 0
+
+    def set_settings_current_profile(self, name: str | None):
+        """Set or clear the current active profile.
+
+        If name is None, the setting is removed.
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            if name is None:
+                conn.execute("DELETE FROM settings WHERE key = 'current_profile'")
+            else:
+                conn.execute(
+                    "INSERT OR REPLACE INTO settings (key, value) VALUES ('current_profile', ?)",
+                    (name,),
+                )
+            conn.commit()
+
+    def get_settings_current_profile_name(self) -> str | None:
+        """Get the name of the current active profile"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT value FROM settings WHERE key = 'current_profile'"
+            )
+            row = cursor.fetchone()
+            return row[0] if row else None
+
+    def get_current_profile(self, env_url: str) -> Auth | None:
+        """Get the current active profile"""
+        current_name = self.get_settings_current_profile_name()
+        if current_name:
+            return self.get_profile(current_name, env_url)
+        return None
+
+    def set_project(self, profile_name: str, env_url: 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 project_id = ? WHERE name = ? AND api_url = ?",
+                (project_id, profile_name, env_url),
+            )
+            conn.commit()
+            return cursor.rowcount > 0
+
+    # Environment management APIs
+    def create_or_update_environment(
+        self, api_url: str, requires_auth: bool, min_llamactl_version: str | None = None
+    ) -> None:
+        """Create or update an environment row."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO environments (api_url, requires_auth, min_llamactl_version) VALUES (?, ?, ?)",
+                (api_url, 1 if requires_auth else 0, min_llamactl_version),
+            )
+            conn.commit()
+
+    def get_environment(self, api_url: str) -> Environment | None:
+        """Retrieve an environment by URL."""
+        with sqlite3.connect(self.db_path) as conn:
+            row = conn.execute(
+                "SELECT api_url, requires_auth, min_llamactl_version FROM environments WHERE api_url = ?",
+                (api_url,),
+            ).fetchone()
+            if row:
+                return _to_environment(row)
+        return None
+
+    def list_environments(self) -> list[Environment]:
+        """List all environments."""
+        with sqlite3.connect(self.db_path) as conn:
+            envs = [
+                _to_environment(row)
+                for row in conn.execute(
+                    "SELECT api_url, requires_auth, min_llamactl_version FROM environments ORDER BY api_url"
+                ).fetchall()
+            ]
+            if not envs:
+                envs = [DEFAULT_ENVIRONMENT]
+            return envs
+
+    def set_settings_current_environment(self, api_url: str) -> None:
+        """Set the current environment by URL.
+
+        Requires the environment row to already exist (validated elsewhere, e.g. via
+        a probe before creation). Raises ValueError if not found.
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO settings (key, value) VALUES ('current_environment_api_url', ?)",
+                (api_url,),
+            )
+            conn.commit()
+
+    def get_current_environment(self) -> Environment:
+        """Get the current environment.
+
+        Ensures there is a settings entry and a corresponding row in `environments`.
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT value FROM settings WHERE key = 'current_environment_api_url'"
+            )
+            row = cursor.fetchone()
+            api_url = row[0] if row else DEFAULT_ENVIRONMENT.api_url
+            if not row:
+                conn.execute(
+                    "INSERT OR REPLACE INTO settings (key, value) VALUES ('current_environment_api_url', ?)",
+                    (api_url,),
+                )
+
+            # Ensure environment exists
+            conn.execute(
+                "INSERT OR IGNORE INTO environments (api_url, requires_auth, min_llamactl_version) VALUES (?, ?, ?)",
+                (
+                    api_url,
+                    1 if DEFAULT_ENVIRONMENT.requires_auth else 0,
+                    DEFAULT_ENVIRONMENT.min_llamactl_version,
+                ),
+            )
+
+            # Read the environment
+            env_row = conn.execute(
+                "SELECT api_url, requires_auth, min_llamactl_version FROM environments WHERE api_url = ?",
+                (api_url,),
+            ).fetchone()
+            if env_row:
+                return _to_environment(env_row)
+
+        # If we somehow got here without returning, raise an error
+        raise RuntimeError("Failed to load current environment")
+
+    def delete_environment(self, api_url: str) -> bool:
+        """Delete an environment and all associated profiles.
+
+        Returns True if the environment existed and was deleted, False otherwise.
+        If the deleted environment was current, switch current to the default URL.
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            # Check existence
+            exists_cursor = conn.execute(
+                "SELECT 1 FROM environments WHERE api_url = ?",
+                (api_url,),
+            )
+            if exists_cursor.fetchone() is None:
+                return False
+
+            # Delete profiles tied to this environment
+            conn.execute("DELETE FROM profiles WHERE api_url = ?", (api_url,))
+
+            # Delete environment row
+            conn.execute("DELETE FROM environments WHERE api_url = ?", (api_url,))
+
+            # If current environment is this one, reset to default
+            setting_cursor = conn.execute(
+                "SELECT value FROM settings WHERE key = 'current_environment_api_url'"
+            )
+            row = setting_cursor.fetchone()
+            if row and row[0] == api_url:
+                conn.execute(
+                    "INSERT OR REPLACE INTO settings (key, value) VALUES ('current_environment_api_url', ?)",
+                    (DEFAULT_ENVIRONMENT.api_url,),
+                )
+
+            conn.commit()
+            return True
+
+
+# Global config manager instance
+config_manager = ConfigManager()

llama_deploy/cli/config/auth_service.py

@@ -0,0 +1,68 @@
+import asyncio
+
+from llama_deploy.cli.config._config import Auth, ConfigManager, Environment
+from llama_deploy.core.client.manage_client import ControlPlaneClient
+from llama_deploy.core.schema import VersionResponse
+from llama_deploy.core.schema.projects import ProjectSummary
+
+
+class AuthService:
+    def __init__(self, config_manager: ConfigManager, env: Environment):
+        self.config_manager = config_manager
+        self.env = env
+
+    def list_profiles(self) -> list[Auth]:
+        return self.config_manager.list_profiles(self.env.api_url)
+
+    def get_profile(self, name: str) -> Auth | None:
+        return self.config_manager.get_profile(name, self.env.api_url)
+
+    def set_current_profile(self, name: str) -> None:
+        self.config_manager.set_settings_current_profile(name)
+
+    def select_any_profile(self) -> None:
+        # best effort to select a profile within the environment
+        profiles = self.list_profiles()
+        if profiles:
+            self.set_current_profile(profiles[0].name)
+
+    def get_current_profile(self) -> Auth | None:
+        return self.config_manager.get_current_profile(self.env.api_url)
+
+    def create_profile_from_token(self, project_id: str, api_key: str | None) -> Auth:
+        base = _auto_profile_name_from_token(api_key or "") if api_key else "default"
+        auth = self.config_manager.create_profile(
+            base, self.env.api_url, project_id, api_key
+        )
+        self.config_manager.set_settings_current_profile(auth.name)
+        return auth
+
+    def delete_profile(self, name: str) -> bool:
+        return self.config_manager.delete_profile(name, self.env.api_url)
+
+    def set_project(self, name: str, project_id: str) -> None:
+        self.config_manager.set_project(name, self.env.api_url, project_id)
+
+    def fetch_server_version(self) -> VersionResponse:
+        async def _fetch_server_version() -> VersionResponse:
+            async with ControlPlaneClient.ctx(self.env.api_url) as client:
+                version = await client.server_version()
+                return version
+
+        return asyncio.run(_fetch_server_version())
+
+    def _validate_token_and_list_projects(self, api_key: str) -> list[ProjectSummary]:
+        async def _run():
+            async with ControlPlaneClient.ctx(self.env.api_url, api_key) as client:
+                return await client.list_projects()
+
+        return asyncio.run(_run())
+
+
+def _auto_profile_name_from_token(api_key: str) -> str:
+    token = api_key or "token"
+    cleaned = token.replace(" ", "")
+    first = cleaned[:6]
+    last = cleaned[-4:] if len(cleaned) > 10 else cleaned[-2:]
+    base = f"token-{first}-{last}"
+    return base

llama_deploy/cli/config/env_service.py

@@ -0,0 +1,64 @@
+from dataclasses import replace
+
+from llama_deploy.cli.config.schema import Environment
+
+from ._config import ConfigManager, config_manager
+from .auth_service import AuthService
+
+
+class EnvService:
+    def __init__(self, config_manager: ConfigManager):
+        self.config_manager = config_manager
+
+    def list_environments(self) -> list[Environment]:
+        return self.config_manager.list_environments()
+
+    def get_current_environment(self) -> Environment:
+        return self.config_manager.get_current_environment()
+
+    def switch_environment(self, api_url: str) -> Environment:
+        env = self.config_manager.get_environment(api_url)
+        if not env:
+            raise ValueError(
+                f"Environment '{api_url}' not found. Add it with 'llamactl auth env add <API_URL>'"
+            )
+        self.config_manager.set_settings_current_environment(api_url)
+        self.config_manager.set_settings_current_profile(None)
+        return env
+
+    def create_or_update_environment(self, env: Environment) -> None:
+        self.config_manager.create_or_update_environment(
+            env.api_url, env.requires_auth, env.min_llamactl_version
+        )
+
+    def delete_environment(self, api_url: str) -> bool:
+        return self.config_manager.delete_environment(api_url)
+
+    def current_auth_service(self) -> AuthService:
+        return AuthService(self.config_manager, self.get_current_environment())
+
+    def auto_update_env(self, env: Environment) -> Environment:
+        svc = AuthService(self.config_manager, env)
+        version = svc.fetch_server_version()
+        update = replace(env)
+        update.requires_auth = version.requires_auth
+        update.min_llamactl_version = version.min_llamactl_version
+        if update != env:
+            self.config_manager.create_or_update_environment(
+                update.api_url, update.requires_auth, update.min_llamactl_version
+            )
+        return update
+
+    def probe_environment(self, api_url: str) -> Environment:
+        clean = api_url.rstrip("/")
+        base_env = Environment(
+            api_url=clean, requires_auth=False, min_llamactl_version=None
+        )
+        svc = AuthService(self.config_manager, base_env)
+        version = svc.fetch_server_version()
+        base_env.requires_auth = version.requires_auth
+        base_env.min_llamactl_version = version.min_llamactl_version
+        return base_env
+
+
+service = EnvService(config_manager)

llama_deploy/cli/config/schema.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Auth:
+    """Auth Profile configuration"""
+
+    name: str
+    api_url: str
+    project_id: str
+    api_key: str | None = None
+
+
+@dataclass
+class Environment:
+    """Environment configuration stored in SQLite.
+
+    Note: `api_url`, `requires_auth`, and `min_llamactl_version` are persisted
+    in the environments table.
+    """
+
+    api_url: str
+    requires_auth: bool
+    min_llamactl_version: str | None = None
+
+
+DEFAULT_ENVIRONMENT = Environment(
+    api_url="https://api.cloud.llamaindex.ai",
+    requires_auth=True,
+    min_llamactl_version=None,
+)

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

@@ -1,84 +1,20 @@
 """Shared utilities for CLI operations"""
 
 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.
-    """
-    if profile_name:
-        return profile_name
-
-    try:
-        profiles = config_manager.list_profiles()
-
-        if not profiles:
-            rprint("[yellow]No profiles found[/yellow]")
-            return None
-
-        choices = []
-        current_name = config_manager.get_current_profile_name()
-
-        for profile in profiles:
-            title = f"{profile.name} ({profile.api_url})"
-            if profile.name == current_name:
-                title += " [current]"
-            choices.append(questionary.Choice(title=title, value=profile.name))
-
-        return questionary.select("Select profile:", choices=choices).ask()
-
-    except Exception as e:
-        rprint(f"[red]Error loading profiles: {e}[/red]")
-        return 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