llamactl 0.3.0a19__py3-none-any.whl → 0.3.0a21__py3-none-any.whl

llama_deploy/cli/config/env_service.py

@@ -1,4 +1,5 @@
 from dataclasses import replace
+from typing import Callable
 
 from llama_deploy.cli.config.schema import Environment
 
@@ -7,46 +8,46 @@ from .auth_service import AuthService
 
 
 class EnvService:
-    def __init__(self, config_manager: ConfigManager):
+    def __init__(self, config_manager: Callable[[], ConfigManager]):
         self.config_manager = config_manager
 
     def list_environments(self) -> list[Environment]:
-        return self.config_manager.list_environments()
+        return self.config_manager().list_environments()
 
     def get_current_environment(self) -> Environment:
-        return self.config_manager.get_current_environment()
+        return self.config_manager().get_current_environment()
 
     def switch_environment(self, api_url: str) -> Environment:
-        env = self.config_manager.get_environment(api_url)
+        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)
+        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(
+        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)
+        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)
+        return self.config_manager().delete_environment(api_url)
 
     def current_auth_service(self) -> AuthService:
-        return AuthService(self.config_manager, self.get_current_environment())
+        return AuthService(self.config_manager(), self.get_current_environment())
 
     def auto_update_env(self, env: Environment) -> Environment:
-        svc = AuthService(self.config_manager, env)
+        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(
+            self.config_manager().create_or_update_environment(
                 update.api_url, update.requires_auth, update.min_llamactl_version
             )
         return update
@@ -56,7 +57,7 @@ class EnvService:
         base_env = Environment(
             api_url=clean, requires_auth=False, min_llamactl_version=None
         )
-        svc = AuthService(self.config_manager, base_env)
+        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

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);

llama_deploy/cli/config/migrations/0002_add_auth_fields.sql

@@ -0,0 +1,24 @@
+PRAGMA user_version=2;
+
+-- Add new fields to profiles: api_key_id and device_oidc (stored as JSON string)
+ALTER TABLE profiles ADD COLUMN api_key_id TEXT;
+ALTER TABLE profiles ADD COLUMN device_oidc TEXT;
+
+-- Add synthetic identifier for profiles
+ALTER TABLE profiles ADD COLUMN id TEXT;
+
+-- Populate existing rows with random UUIDv4 values
+UPDATE profiles
+SET id = lower(
+    hex(randomblob(4)) || '-' ||
+    hex(randomblob(2)) || '-' ||
+    '4' || substr(hex(randomblob(2)), 2) || '-' ||
+    substr('89ab', 1 + (abs(random()) % 4), 1) || substr(hex(randomblob(2)), 2) || '-' ||
+    hex(randomblob(6))
+)
+WHERE id IS NULL;
+
+-- Ensure id values are unique
+CREATE UNIQUE INDEX IF NOT EXISTS idx_profiles_id ON profiles(id);
+
+

llama_deploy/cli/config/migrations/__init__.py

@@ -0,0 +1,7 @@
+"""SQL migrations for llamactl configuration database.
+
+Files are applied in lexicographic order and must start with:
+
+    PRAGMA user_version=N;
+
+"""

llama_deploy/cli/config/schema.py

@@ -1,14 +1,44 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 
+from pydantic import BaseModel
+
 
 @dataclass
 class Auth:
     """Auth Profile configuration"""
 
+    id: str
     name: str
     api_url: str
     project_id: str
     api_key: str | None = None
+    # reference to the API key if we created it from device oauth, to be cleaned up
+    # once de-authenticated
+    api_key_id: str | None = None
+    device_oidc: DeviceOIDC | None = None
+
+
+class DeviceOIDC(BaseModel):
+    """Device OIDC configuration"""
+
+    # A name for this device, derived from the host. Used in API key name.
+    device_name: str
+    # A unique user ID to identify the user in the API. Prevents duplicate logins.
+    user_id: str
+    # email of the user
+    email: str
+    # OIDC client ID
+    client_id: str
+    # OIDC discovery URL
+    discovery_url: str
+    # usually 5m long JWT. For calling APIs.
+    device_access_token: str
+    # usually opaque, used to get new access tokens
+    device_refresh_token: str | None = None
+    # usually 1h long JWT. Contains user info (email, name, etc.)
+    device_id_token: str | None = None
 
 
 @dataclass

llama_deploy/cli/env.py

@@ -4,6 +4,7 @@ from io import StringIO
 from typing import Dict
 
 from dotenv import dotenv_values
+from llama_deploy.cli.styles import WARNING
 from rich import print as rprint
 
 
@@ -26,6 +27,6 @@ def load_env_secrets_from_string(env_content: str) -> Dict[str, str]:
         return {k: str(v) for k, v in secrets.items() if v is not None}
     except Exception as e:
         rprint(
-            f"[yellow]Warning: Could not parse environment variables from string: {e}[/yellow]"
+            f"[{WARNING}]Warning: Could not parse environment variables from string: {e}[/]"
         )
         return {}

llama_deploy/cli/styles.py

@@ -0,0 +1,10 @@
+# A place to centralize design tokens to simplify tweaking the appearance of the CLI
+# See https://rich.readthedocs.io/en/stable/appendix/colors.html
+
+
+HEADER_COLOR = "cornflower_blue"
+HEADER_COLOR_HEX = "#5f87ff"
+PRIMARY_COL = "default"
+MUTED_COL = "grey46"
+WARNING = "yellow"
+ACTIVE_INDICATOR = "magenta"

llama_deploy/cli/textual/deployment_form.py

@@ -30,8 +30,10 @@ from llama_deploy.core.deployment_config import (
 from llama_deploy.core.git.git_util import (
     get_current_branch,
     get_git_root,
+    get_unpushed_commits_count,
     is_git_repo,
     list_remotes,
+    working_tree_has_changes,
 )
 from llama_deploy.core.schema.deployments import (
     DeploymentCreate,
@@ -69,6 +71,10 @@ class DeploymentForm:
     removed_secrets: set[str] = field(default_factory=set)
     # if the deployment is being edited
     is_editing: bool = False
+    # warnings shown to the user
+    warnings: list[str] = field(default_factory=list)
+    # env info
+    env_info_messages: str | None = None
 
     @classmethod
     def from_deployment(cls, deployment: DeploymentResponse) -> "DeploymentForm":
@@ -154,6 +160,13 @@ class DeploymentFormWidget(Widget):
             id="error-message",
             classes="error-message " + ("visible" if self.error_message else "hidden"),
         )
+        # Top-of-form warnings banner
+        yield Static(
+            "Note: " + " ".join(f"{w}" for w in self.form_data.warnings),
+            id="warning-list",
+            classes="warning-message mb-1 hidden "
+            + ("visible" if self.form_data.warnings else ""),
+        )
 
         # Main deployment fields
         with Widget(classes="two-column-form-grid"):
@@ -217,6 +230,7 @@ class DeploymentFormWidget(Widget):
         yield SecretsWidget(
             initial_secrets=self.form_data.secrets,
             prior_secrets=self.form_data.initial_secrets,
+            info_message=self.form_data.env_info_messages,
         )
 
         with HorizontalGroup(classes="button-row"):
@@ -501,7 +515,29 @@ def _initialize_deployment_data() -> DeploymentForm:
     secrets: dict[str, str] = {}
     name: str | None = None
     config_file_path: str | None = None
-    if is_git_repo():
+    warnings: list[str] = []
+    has_git = is_git_repo()
+    has_no_workflows = False
+    try:
+        config = read_deployment_config(Path("."), Path("."))
+        if config.name != DEFAULT_DEPLOYMENT_NAME:
+            name = config.name
+        has_no_workflows = config.has_no_workflows()
+    except Exception:
+        warnings.append("Could not parse local deployment config. It may be invalid.")
+    if not has_git and has_no_workflows:
+        warnings = [
+            "Run from within a git repository to automatically generate a deployment config."
+        ]
+    elif has_no_workflows:
+        warnings = [
+            "The current project has no workflows configured. It may be invalid."
+        ]
+    elif not has_git:
+        warnings.append(
+            "Current directory is not a git repository. If you are trying to deploy this directory, you will need to create a git repository and push it before creating a deployment."
+        )
+    else:
         seen = set[str]()
         remotes = list_remotes()
         candidate_origins = []
@@ -520,14 +556,32 @@ def _initialize_deployment_data() -> DeploymentForm:
         if root != Path.cwd():
             config_file_path = str(Path.cwd().relative_to(root))
 
+        if not preferred_origin:
+            warnings.append(
+                "No git remote was found. You will need to push your changes to a remote repository before creating a deployment from this repository."
+            )
+        else:
+            # Working tree changes
+            if working_tree_has_changes() and preferred_origin:
+                warnings.append(
+                    "Working tree has uncommitted or untracked changes. You may want to push them before creating a deployment from this branch."
+                )
+            else:
+                # Unpushed commits (ahead of upstream)
+                ahead = get_unpushed_commits_count()
+                if ahead is None:
+                    warnings.append(
+                        "Current branch has no upstream configured. You will need to push them or choose a different branch."
+                    )
+                elif ahead > 0:
+                    warnings.append(
+                        f"There are {ahead} local commits not pushed to upstream. They won't be included in the deployment unless you push them first."
+                    )
+    env_info_message = None
     if Path(".env").exists():
         secrets = load_env_secrets_from_string(Path(".env").read_text())
-    try:
-        config = read_deployment_config(Path("."), Path("."))
-        if config.name != DEFAULT_DEPLOYMENT_NAME:
-            name = config.name
-    except Exception:
-        pass
+        if len(secrets) > 0:
+            env_info_message = "Secrets were automatically seeded from your .env file. Remove or change any that should not be set. They must be manually configured after creation."
 
     form = DeploymentForm(
         name=name or "",
@@ -535,6 +589,8 @@ def _initialize_deployment_data() -> DeploymentForm:
         git_ref=git_ref or "main",
         secrets=secrets,
         deployment_file_path=config_file_path or "",
+        warnings=warnings,
+        env_info_messages=env_info_message,
     )
     return form
 

llama_deploy/cli/textual/deployment_monitor.py

@@ -6,13 +6,14 @@ import asyncio
 import hashlib
 import logging
 import threading
-import time
 import webbrowser
+from collections.abc import AsyncGenerator
 from pathlib import Path
 
 from llama_deploy.cli.client import (
     project_client_context,
 )
+from llama_deploy.core.iter_utils import merge_generators
 from llama_deploy.core.schema import LogEvent
 from llama_deploy.core.schema.deployments import DeploymentResponse
 from rich.text import Text
@@ -20,9 +21,11 @@ from textual import events
 from textual.app import App, ComposeResult
 from textual.containers import Container, HorizontalGroup, Widget
 from textual.content import Content
+from textual.css.query import NoMatches
 from textual.message import Message
 from textual.reactive import reactive
 from textual.widgets import Button, RichLog, Static
+from typing_extensions import Literal
 
 logger = logging.getLogger(__name__)
 
@@ -87,7 +90,12 @@ class DeploymentMonitorWidget(Widget):
         content-align: left middle;
     }
 
-
+    .log-view-container {
+        width: 1fr;
+        height: 1fr;
+        padding: 0;
+        margin: 0;
+    }
 	"""
 
     deployment_id: str
@@ -102,11 +110,14 @@ class DeploymentMonitorWidget(Widget):
         self._stop_stream = threading.Event()
         # Persist content written to the RichLog across recomposes
         self._log_buffer: list[Text] = []
+        self._log_stream_started = False
 
     async def on_mount(self) -> None:
         # Kick off initial fetch and start logs stream in background
         self.run_worker(self._fetch_deployment())
-        self.run_worker(self._stream_logs())
+        # Force an initial layout, then start the log stream after that layout completes
+        self.refresh(layout=True)
+        self.call_after_refresh(lambda: self.run_worker(self._stream_logs()))
         # Start periodic polling of deployment status
         self.run_worker(self._poll_deployment_status())
 
@@ -131,16 +142,8 @@ class DeploymentMonitorWidget(Widget):
             )
             yield Static("", classes="status-right", id="last_event_status")
         yield Static("", classes="last-event", id="last_event_details")
-        yield Static("")  # just a spacer
-
         yield Static("Logs", classes="secondary-message log-header")
-        yield RichLog(
-            id="log_view",
-            classes="log-view mb-1",
-            auto_scroll=self.autoscroll_enabled,
-            wrap=self.wrap_enabled,
-            highlight=True,
-        )
+        yield HorizontalGroup(classes="log-view-container", id="log_view_container")
 
         with HorizontalGroup(classes="button-row"):
             wrap_label = "Wrap: On" if self.wrap_enabled else "Wrap: Off"
@@ -180,113 +183,45 @@ class DeploymentMonitorWidget(Widget):
     async def _stream_logs(self) -> None:
         """Consume the async log iterator, batch updates, and reconnect with backoff."""
 
-        async def _sleep_with_cancel(total_seconds: float) -> None:
-            step = 0.2
-            remaining = total_seconds
-            while remaining > 0 and not self._stop_stream.is_set():
-                await asyncio.sleep(min(step, remaining))
-                remaining -= step
-
-        # Batching configuration: small latency to reduce UI churn while staying responsive
-        batch_max_latency_seconds = 0.1
-        batch_max_items = 200
-
-        base_backoff_seconds = 0.2
-        backoff_seconds = base_backoff_seconds
-        max_backoff_seconds = 30.0
+        async def _flush_signal(
+            frequency_seconds: float,
+        ) -> AsyncGenerator[Literal["__FLUSH__"], None]:
+            while not self._stop_stream.is_set():
+                await asyncio.sleep(frequency_seconds)
+                yield "__FLUSH__"
 
+        failures = 0
         while not self._stop_stream.is_set():
-            connect_started_at = time.monotonic()
-            # On any (re)connect, clear existing content
-            self._reset_log_view_for_reconnect()
-
-            queue: asyncio.Queue[LogEvent] = asyncio.Queue(maxsize=10000)
-            producer_done = asyncio.Event()
-
-            async def _producer() -> None:
+            async with project_client_context() as client:
+                await asyncio.sleep(min(failures, 10))
+                batch: list[LogEvent] = []
                 try:
-                    async with project_client_context() as client:
-                        async for event in client.stream_deployment_logs(
+                    logger.info(f"Streaming logs for deployment {self.deployment_id}")
+                    async for event in merge_generators(
+                        client.stream_deployment_logs(
                             self.deployment_id,
                             include_init_containers=True,
                             tail_lines=10000,
-                        ):
-                            if self._stop_stream.is_set():
-                                break
-                            try:
-                                await queue.put(event)
-                            except Exception:
-                                # If queue put fails due to cancellation/shutdown, stop
-                                break
+                        ),
+                        _flush_signal(0.2),
+                    ):
+                        if event == "__FLUSH__" and batch:
+                            self._handle_log_events(batch)
+                            batch = []
+                        elif isinstance(event, LogEvent):
+                            batch.append(event)
+                            if len(batch) >= 1000:
+                                self._handle_log_events(batch)
+                                batch = []
                 except Exception as e:
-                    # Surface error via error message and rely on reconnect loop
                     if not self._stop_stream.is_set():
                         self._set_error_message(
                             f"Log stream failed: {e}. Reconnecting..."
                         )
+                        failures += 1
                 finally:
-                    producer_done.set()
-
-            async def _consumer() -> None:
-                batch: list[LogEvent] = []
-                next_deadline = time.monotonic() + batch_max_latency_seconds
-                while not self._stop_stream.is_set():
-                    # Stop once producer finished and queue drained
-                    if producer_done.is_set() and queue.empty():
-                        if batch:
-                            self._handle_log_events(batch)
-                            batch = []
-                        break
-                    timeout = max(0.0, next_deadline - time.monotonic())
-                    try:
-                        item = await asyncio.wait_for(queue.get(), timeout=timeout)
-                        batch.append(item)
-                        if len(batch) >= batch_max_items:
-                            self._handle_log_events(batch)
-                            batch = []
-                            next_deadline = time.monotonic() + batch_max_latency_seconds
-                    except asyncio.TimeoutError:
-                        if batch:
-                            self._handle_log_events(batch)
-                            batch = []
-                        next_deadline = time.monotonic() + batch_max_latency_seconds
-                    except Exception:
-                        # On any unexpected error, flush and exit, reconnect will handle
-                        if batch:
-                            self._handle_log_events(batch)
-                        break
-
-            producer_task = asyncio.create_task(_producer())
-            try:
-                await _consumer()
-            finally:
-                # Ensure producer is not left running
-                try:
-                    producer_task.cancel()
-                except Exception:
-                    pass
-
-            if self._stop_stream.is_set():
-                break
-
-            # If we reached here, the stream ended or failed; attempt reconnect with backoff
-            self._set_error_message("Log stream disconnected. Reconnecting...")
-
-            # Duration-aware backoff (smaller when the previous connection lived longer)
-            connection_lifetime = 0.0
-            try:
-                connection_lifetime = max(0.0, time.monotonic() - connect_started_at)
-            except Exception:
-                connection_lifetime = 0.0
-
-            if connection_lifetime >= backoff_seconds:
-                backoff_seconds = base_backoff_seconds
-            else:
-                backoff_seconds = min(backoff_seconds * 2.0, max_backoff_seconds)
-
-            delay = max(0.0, backoff_seconds - connection_lifetime)
-            if delay > 0:
-                await _sleep_with_cancel(delay)
+                    if batch:
+                        self._handle_log_events(batch)
 
     def _reset_log_view_for_reconnect(self) -> None:
         """Clear UI and buffers so new stream replaces previous content."""
@@ -313,10 +248,26 @@ class DeploymentMonitorWidget(Widget):
         if not texts:
             return
 
-        log_widget = self.query_one("#log_view", RichLog)
+        try:
+            # due to bugs in the the RichLog widget, defer mounting, otherwise it won't get a "ResizeEvent" (on_resize), and be waiting indefinitely
+            # before it renders (unless you manually resize the terminal window)
+            log_widget = self.query_one("#log_view", RichLog)
+        except NoMatches:
+            log_container = self.query_one("#log_view_container", HorizontalGroup)
+            log_widget = RichLog(
+                id="log_view",
+                classes="log-view mb-1",
+                auto_scroll=self.autoscroll_enabled,
+                wrap=self.wrap_enabled,
+                highlight=True,
+            )
+            log_container.mount(log_widget)
         for text in texts:
             log_widget.write(text)
             self._log_buffer.append(text)
+        log_widget.refresh()
+
+        # One-time kick to ensure initial draw
         # Clear any previous error once we successfully receive logs
         if self.error_message:
             self.error_message = ""
@@ -469,6 +420,18 @@ class MonitorCloseMessage(Message):
     pass
 
 
+class LogBatchMessage(Message):
+    def __init__(self, events: list[LogEvent]) -> None:
+        super().__init__()
+        self.events = events
+
+
+class ErrorTextMessage(Message):
+    def __init__(self, text: str) -> None:
+        super().__init__()
+        self.text = text
+
+
 class DeploymentMonitorApp(App[None]):
     """Standalone app wrapper around the monitor widget.
 

llama_deploy/cli/textual/github_callback_server.py

@@ -191,17 +191,17 @@ async def main():
     server = GitHubCallbackServer(port=41010)
 
     # Start server and open browser
-    print(f"Starting GitHub callback server on http://localhost:{server.port}")
-    print("Opening browser to show success page...")
+    logger.debug(f"Starting GitHub callback server on http://localhost:{server.port}")
+    logger.debug("Opening browser to show success page...")
 
     # Open browser to success page to see the styling
     webbrowser.open(f"http://localhost:{server.port}")
 
     try:
         # Wait for callback (or just keep server running)
-        print("Server running... Press Ctrl+C to stop")
+        logger.debug("Server running... Press Ctrl+C to stop")
         callback_data = await server.start_and_wait(timeout=3600)  # 1 hour timeout
-        print(f"Received callback data: {callback_data}")
+        logger.debug(f"Received callback data: {callback_data}")
     finally:
         await server.stop()
 

llama_deploy/cli/textual/secrets_form.py

@@ -67,6 +67,7 @@ class SecretsWidget(Widget):
         self,
         initial_secrets: dict[str, str] | None = None,
         prior_secrets: set[str] | None = None,
+        info_message: str | None = None,
     ):
         super().__init__()
         self.secrets = initial_secrets or {}
@@ -74,6 +75,7 @@ class SecretsWidget(Widget):
         self.visible_secrets = set()
         # Persist textarea content across recomposes triggered by other actions
         self._new_secrets_text = ""
+        self.info_message = info_message
 
     def compose(self) -> ComposeResult:
         """Compose the secrets section - called automatically when secrets change"""
@@ -85,6 +87,8 @@ class SecretsWidget(Widget):
         )
         secret_names = known_secret_names + prior_only_secret_names
         hidden = len(secret_names) == 0
+        if self.info_message:
+            yield Static(self.info_message, classes="secondary-message mb-1")
         with Static(
             classes="secrets-grid" + (" hidden" if hidden else ""),
             id="secrets-grid",