llamactl 0.2.7a1__py3-none-any.whl → 0.3.0__py3-none-any.whl

llama_deploy/cli/config/_config.py

@@ -0,0 +1,390 @@
+"""Configuration and profile management for llamactl"""
+
+import functools
+import os
+import sqlite3
+import uuid
+from pathlib import Path
+from typing import Any
+
+from ._migrations import run_migrations
+from .schema import DEFAULT_ENVIRONMENT, Auth, DeviceOIDC, Environment
+
+
+def _serialize_device_oidc(value: DeviceOIDC | None) -> str | None:
+    if value is None:
+        return None
+    return value.model_dump_json()
+
+
+def _deserialize_device_oidc(value: str | None) -> DeviceOIDC | None:
+    if not value:
+        return None
+    return DeviceOIDC.model_validate_json(value)
+
+
+def _to_auth(row: Any) -> Auth:
+    return Auth(
+        id=row[0],
+        name=row[1],
+        api_url=row[2],
+        project_id=row[3],
+        api_key=row[4],
+        api_key_id=row[5],
+        device_oidc=_deserialize_device_oidc(row[6]),
+    )
+
+
+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, init_database: bool = True):
+        self.config_dir = self._get_config_dir()
+        self.db_path = self.config_dir / "profiles.db"
+        self._ensure_config_dir()
+        if init_database:
+            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 and run migrations; then seed defaults."""
+
+        with sqlite3.connect(self.db_path) as conn:
+            # Apply ad-hoc SQL migrations based on PRAGMA user_version
+            run_migrations(conn)
+
+            conn.commit()
+
+    def destroy_database(self):
+        """Destroy the database"""
+        self.db_path.unlink()
+        self._init_database()
+
+    #############################################
+    ## Settings
+    #############################################
+
+    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 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 create_profile(
+        self,
+        name: str,
+        api_url: str,
+        project_id: str,
+        api_key: str | None = None,
+        api_key_id: str | None = None,
+        device_oidc: DeviceOIDC | None = None,
+    ) -> Auth:
+        """Create a new auth profile"""
+        if not project_id.strip():
+            raise ValueError("Project ID is required")
+        profile = Auth(
+            id=str(uuid.uuid4()),
+            name=name,
+            api_url=api_url,
+            project_id=project_id,
+            api_key=api_key,
+            api_key_id=api_key_id,
+            device_oidc=device_oidc,
+        )
+
+        with sqlite3.connect(self.db_path) as conn:
+            try:
+                conn.execute(
+                    "INSERT INTO profiles (id, name, api_url, project_id, api_key, api_key_id, device_oidc) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                    (
+                        profile.id,
+                        profile.name,
+                        profile.api_url,
+                        profile.project_id,
+                        profile.api_key,
+                        profile.api_key_id,
+                        _serialize_device_oidc(profile.device_oidc),
+                    ),
+                )
+                conn.commit()
+            except sqlite3.IntegrityError:
+                raise ValueError(
+                    f"Profile '{name}' already exists for environment '{api_url}'"
+                )
+
+        return profile
+
+    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 get_current_environment(self) -> Environment:
+        """Get the current active environment"""
+        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
+
+            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)
+
+        # Fallback: return an in-memory default without writing to DB
+        if api_url == DEFAULT_ENVIRONMENT.api_url:
+            return DEFAULT_ENVIRONMENT
+        return Environment(
+            api_url=api_url, requires_auth=False, min_llamactl_version=None
+        )
+
+    ##################################
+    ## Profiles
+    ##################################
+
+    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 id, name, api_url, project_id, api_key, api_key_id, device_oidc FROM profiles WHERE name = ? AND api_url = ?",
+                (name, env_url),
+            ).fetchone()
+            if row:
+                return _to_auth(row)
+        return None
+
+    def get_profile_by_id(self, id: str) -> Auth | None:
+        """Get a profile by ID"""
+        with sqlite3.connect(self.db_path) as conn:
+            row = conn.execute(
+                "SELECT id, name, api_url, project_id, api_key, api_key_id, device_oidc FROM profiles WHERE id = ?",
+                (id,),
+            ).fetchone()
+            if row:
+                return _to_auth(row)
+        return None
+
+    def get_profile_by_api_key(self, env_url: str, api_key: str) -> Auth | None:
+        """Get a profile by api_key within an environment URL."""
+        with sqlite3.connect(self.db_path) as conn:
+            row = conn.execute(
+                """
+                SELECT id, name, api_url, project_id, api_key, api_key_id, device_oidc
+                FROM profiles
+                WHERE api_url = ? AND api_key = ?
+                LIMIT 1
+                """,
+                (env_url, api_key),
+            ).fetchone()
+            if row:
+                return _to_auth(row)
+        return None
+
+    def get_profile_by_device_user_id(self, env_url: str, user_id: str) -> Auth | None:
+        """Get a profile by device OIDC user_id within an environment URL."""
+        with sqlite3.connect(self.db_path) as conn:
+            row = conn.execute(
+                """
+                SELECT id, name, api_url, project_id, api_key, api_key_id, device_oidc
+                FROM profiles
+                WHERE api_url = ? AND JSON_EXTRACT(device_oidc, '$.user_id') = ?
+                LIMIT 1
+                """,
+                (env_url, user_id),
+            ).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 id, name, api_url, project_id, api_key, api_key_id, device_oidc 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_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
+
+    def update_profile(self, profile: Auth) -> None:
+        """Update a profile"""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                "UPDATE profiles SET name = ?, api_url = ?, project_id = ?, api_key = ?, api_key_id = ?, device_oidc = ? WHERE id = ?",
+                (
+                    profile.name,
+                    profile.api_url,
+                    profile.project_id,
+                    profile.api_key,
+                    profile.api_key_id,
+                    _serialize_device_oidc(profile.device_oidc),
+                    profile.id,
+                ),
+            )
+            conn.commit()
+
+    ##################################
+    ## Environments
+    ##################################
+    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 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
+@functools.cache
+def config_manager() -> ConfigManager:
+    return ConfigManager()

llama_deploy/cli/config/_migrations.py

@@ -0,0 +1,65 @@
+"""Ad-hoc SQLite schema migrations using PRAGMA user_version.
+
+Inspired by https://eskerda.com/sqlite-schema-migrations-python/
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import sqlite3
+from importlib import import_module, resources
+from importlib.resources.abc import Traversable
+
+logger = logging.getLogger(__name__)
+
+
+_MIGRATIONS_PKG = "llama_deploy.cli.config.migrations"
+_USER_VERSION_PATTERN = re.compile(r"pragma\s+user_version\s*=\s*(\d+)", re.IGNORECASE)
+
+
+def _iter_migration_files() -> list[Traversable]:
+    """Yield packaged SQL migration files in lexicographic order."""
+    pkg = import_module(_MIGRATIONS_PKG)
+    root = resources.files(pkg)
+    files = (p for p in root.iterdir() if p.name.endswith(".sql"))
+    if not files:
+        raise ValueError("No migration files found")
+    return sorted(files, key=lambda p: p.name)
+
+
+def _parse_target_version(sql_text: str) -> int | None:
+    """Return target schema version declared in the first PRAGMA line, if any."""
+    first_line = sql_text.splitlines()[0] if sql_text else ""
+    match = _USER_VERSION_PATTERN.search(first_line)
+    return int(match.group(1)) if match else None
+
+
+def run_migrations(conn: sqlite3.Connection) -> None:
+    """Apply pending migrations found under the migrations package.
+
+    Each migration file should start with a `PRAGMA user_version=N;` line.
+    Files are applied in lexicographic order and only when N > current_version.
+    """
+    cur = conn.cursor()
+    current_version_row = cur.execute("PRAGMA user_version").fetchone()
+    current_version = int(current_version_row[0]) if current_version_row else 0
+
+    for path in _iter_migration_files():
+        sql_text = path.read_text()
+        target_version = _parse_target_version(sql_text) or 0
+        if target_version <= current_version:
+            continue
+
+        try:
+            logger.debug(
+                "Applying migration %s → target version %s", path.name, target_version
+            )
+            cur.executescript("BEGIN;\n" + sql_text)
+        except Exception as exc:  # noqa: BLE001 – we surface the exact error
+            logger.error("Failed migration %s: %s", path.name, exc)
+            cur.execute("ROLLBACK")
+            raise
+        else:
+            cur.execute("COMMIT")
+            current_version = target_version

llama_deploy/cli/config/auth_service.py

@@ -0,0 +1,130 @@
+import asyncio
+
+from llama_deploy.cli.auth.client import PlatformAuthClient, RefreshMiddleware
+from llama_deploy.cli.config._config import Auth, ConfigManager, Environment
+from llama_deploy.cli.config.schema import DeviceOIDC
+from llama_deploy.core.client.manage_client import ControlPlaneClient, httpx
+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 get_profile_by_id(self, id: str) -> Auth | None:
+        return self.config_manager.get_profile_by_id(id)
+
+    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 create_or_update_profile_from_oidc(
+        self, project_id: str, device_oidc: DeviceOIDC
+    ) -> Auth:
+        base = device_oidc.email
+        existing = self.config_manager.get_profile_by_device_user_id(
+            self.env.api_url, device_oidc.user_id
+        )
+        if existing:
+            existing.device_oidc = device_oidc
+            self.config_manager.update_profile(existing)
+            auth = existing
+        else:
+            auth = self.config_manager.create_profile(
+                base, self.env.api_url, project_id, device_oidc=device_oidc
+            )
+        self.config_manager.set_settings_current_profile(auth.name)
+        return auth
+
+    def update_profile(self, profile: Auth) -> None:
+        self.config_manager.update_profile(profile)
+
+    async def delete_profile(self, name: str) -> bool:
+        profile = self.get_profile(name)
+        if profile and profile.api_key_id:
+            async with self.profile_client(profile) as client:
+                try:
+                    await client.delete_api_key(profile.api_key_id)
+                except Exception:
+                    pass
+        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 auth_middleware(self, profile: Auth | None = None) -> httpx.Auth | None:
+        profile = profile or self.get_current_profile()
+        if profile and profile.device_oidc:
+            _profile = profile  # copy to assist type checker being inflexible
+
+            async def _on_refresh(updated: DeviceOIDC) -> None:
+                # Persist refreshed tokens to the database synchronously within async wrapper
+                self.refresh_to_db(_profile.id, updated)
+
+            return RefreshMiddleware(
+                profile.device_oidc,
+                _on_refresh,
+            )
+        return None
+
+    def refresh_to_db(self, profile_id: str, device_oidc: DeviceOIDC) -> None:
+        profile = self.get_profile_by_id(profile_id)
+        if profile:
+            profile.device_oidc = device_oidc
+            self.config_manager.update_profile(profile)
+
+    def profile_client(self, profile: Auth | None = None) -> PlatformAuthClient:
+        profile = profile or self.get_current_profile()
+        if not profile:
+            raise ValueError("No active profile")
+        return PlatformAuthClient(
+            profile.api_url, profile.api_key, self.auth_middleware(profile)
+        )
+
+
+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"{first}****{last}"
+    return base

llama_deploy/cli/config/env_service.py

@@ -0,0 +1,67 @@
+from dataclasses import replace
+from typing import Callable
+
+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: Callable[[], 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
+        )
+        self.config_manager().set_settings_current_environment(env.api_url)
+        self.config_manager().set_settings_current_profile(None)
+
+    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/migrations/0001_init.sql

@@ -0,0 +1,35 @@
+PRAGMA user_version=1;
+
+-- Initial schema for llamactl config database
+
+CREATE TABLE IF NOT EXISTS profiles (
+    name TEXT NOT NULL,
+    api_url TEXT NOT NULL,
+    project_id TEXT NOT NULL,
+    api_key TEXT,
+    PRIMARY KEY (name, api_url)
+);
+
+CREATE TABLE IF NOT EXISTS settings (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS environments (
+    api_url TEXT PRIMARY KEY,
+    requires_auth INTEGER NOT NULL,
+    min_llamactl_version TEXT
+);
+
+-- Seed defaults (idempotent)
+-- 1) Ensure current environment setting exists (do not overwrite if already set)
+INSERT OR IGNORE INTO settings (key, value)
+VALUES ('current_environment_api_url', 'https://api.cloud.llamaindex.ai');
+
+-- 2) Backfill environments from any existing profiles (avoid duplicates)
+INSERT OR IGNORE INTO environments (api_url, requires_auth)
+SELECT DISTINCT api_url, 0 FROM profiles;
+
+-- 3) Ensure the default cloud environment exists with auth required
+INSERT OR IGNORE INTO environments (api_url, requires_auth, min_llamactl_version)
+VALUES ('https://api.cloud.llamaindex.ai', 1, NULL);