llamactl 0.3.0a6__py3-none-any.whl → 0.3.0a8__py3-none-any.whl

llama_deploy/cli/textual/deployment_form.py

@@ -2,7 +2,6 @@
 
 import dataclasses
 import logging
-import os
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -14,14 +13,26 @@ from llama_deploy.cli.textual.deployment_help import (
     DeploymentHelpBackMessage,
     DeploymentHelpWidget,
 )
+from llama_deploy.cli.textual.deployment_monitor import (
+    DeploymentMonitorWidget,
+    MonitorCloseMessage,
+)
 from llama_deploy.cli.textual.git_validation import (
     GitValidationWidget,
     ValidationCancelMessage,
     ValidationResultMessage,
 )
 from llama_deploy.cli.textual.secrets_form import SecretsWidget
-from llama_deploy.core.deployment_config import DeploymentConfig
-from llama_deploy.core.git.git_util import get_current_branch, is_git_repo, list_remotes
+from llama_deploy.core.deployment_config import (
+    DEFAULT_DEPLOYMENT_NAME,
+    read_deployment_config,
+)
+from llama_deploy.core.git.git_util import (
+    get_current_branch,
+    get_git_root,
+    is_git_repo,
+    list_remotes,
+)
 from llama_deploy.core.schema.deployments import (
     DeploymentCreate,
     DeploymentResponse,
@@ -45,7 +56,7 @@ class DeploymentForm:
     id: str | None = None
     repo_url: str = ""
     git_ref: str = "main"
-    deployment_file_path: str = "llama_deploy.yaml"
+    deployment_file_path: str = ""
     personal_access_token: str = ""
     # indicates if the deployment has a personal access token (value is unknown)
     has_existing_pat: bool = False
@@ -67,7 +78,7 @@ class DeploymentForm:
             id=deployment.id,
             repo_url=deployment.repo_url,
             git_ref=deployment.git_ref or "main",
-            deployment_file_path=deployment.deployment_file_path or "llama_deploy.yaml",
+            deployment_file_path=deployment.deployment_file_path,
             personal_access_token="",  # Always start empty for security
             has_existing_pat=deployment.has_personal_access_token,
             secrets={},
@@ -85,7 +96,7 @@ class DeploymentForm:
         data = DeploymentUpdate(
             repo_url=self.repo_url,
             git_ref=self.git_ref or "main",
-            deployment_file_path=self.deployment_file_path or "llama_deploy.yaml",
+            deployment_file_path=self.deployment_file_path or None,
             personal_access_token=(
                 ""
                 if self.personal_access_token is None and not self.has_existing_pat
@@ -102,7 +113,7 @@ class DeploymentForm:
         return DeploymentCreate(
             name=self.name,
             repo_url=self.repo_url,
-            deployment_file_path=self.deployment_file_path or "llama_deploy.yaml",
+            deployment_file_path=self.deployment_file_path or None,
             git_ref=self.git_ref or "main",
             personal_access_token=self.personal_access_token,
             secrets=self.secrets,
@@ -175,10 +186,10 @@ class DeploymentFormWidget(Widget):
                 compact=True,
             )
 
-            yield Label("Deployment File:", classes="form-label", shrink=True)
+            yield Label("Config File:", classes="form-label", shrink=True)
             yield Input(
                 value=self.form_data.deployment_file_path,
-                placeholder="llama_deploy.yaml",
+                placeholder="Optional path to config dir/file",
                 id="deployment_file_path",
                 compact=True,
             )
@@ -283,8 +294,7 @@ class DeploymentFormWidget(Widget):
             id=self.form_data.id,
             repo_url=repo_url_input.value.strip(),
             git_ref=git_ref_input.value.strip() or "main",
-            deployment_file_path=deployment_file_input.value.strip()
-            or "llama_deploy.yaml",
+            deployment_file_path=deployment_file_input.value.strip(),
             personal_access_token=pat_value,
             secrets=updated_secrets,
             initial_secrets=self.original_form_data.initial_secrets,
@@ -328,10 +338,11 @@ class DeploymentEditApp(App[DeploymentResponse | None]):
 
     CSS_PATH = Path(__file__).parent / "styles.tcss"
 
-    # App states: 'form', 'validation', or 'help'
+    # App states: 'form', 'validation', 'help', or 'monitor'
     current_state: reactive[str] = reactive("form", recompose=True)
     form_data: reactive[DeploymentForm] = reactive(DeploymentForm())
     save_error: reactive[str] = reactive("", recompose=True)
+    saved_deployment = reactive[DeploymentResponse | None](None, recompose=True)
 
     def __init__(self, initial_data: DeploymentForm):
         super().__init__()
@@ -344,10 +355,14 @@ class DeploymentEditApp(App[DeploymentResponse | None]):
     def on_key(self, event) -> None:
         """Handle key events, including Ctrl+C"""
         if event.key == "ctrl+c":
-            self.exit(None)
+            if self.current_state == "monitor" and self.saved_deployment is not None:
+                self.exit(self.saved_deployment)
+            else:
+                self.exit(None)
 
     def compose(self) -> ComposeResult:
-        with Container(classes="form-container"):
+        is_slim = self.current_state != "monitor"
+        with Container(classes="form-container" if is_slim else ""):
             if self.current_state == "form":
                 yield DeploymentFormWidget(self.form_data, self.save_error)
             elif self.current_state == "validation":
@@ -362,6 +377,11 @@ class DeploymentEditApp(App[DeploymentResponse | None]):
                 )
             elif self.current_state == "help":
                 yield DeploymentHelpWidget()
+            elif self.current_state == "monitor":
+                deployment_id = (
+                    self.saved_deployment.id if self.saved_deployment else ""
+                )
+                yield DeploymentMonitorWidget(deployment_id)
             else:
                 yield Static("Unknown state: " + self.current_state)
 
@@ -426,8 +446,15 @@ class DeploymentEditApp(App[DeploymentResponse | None]):
                 )
             else:
                 update_deployment = client.create_deployment(result.to_create())
-            # Exit with result
-            self.exit(update_deployment)
+            # Save and navigate to embedded monitor screen
+            self.saved_deployment = update_deployment
+            # Ensure form_data carries the new ID for any subsequent operations
+            if not result.is_editing and update_deployment.id:
+                updated_form = dataclasses.replace(self.form_data)
+                updated_form.id = update_deployment.id
+                updated_form.is_editing = True
+                self.form_data = updated_form
+            self.current_state = "monitor"
         except Exception as e:
             # Return to form and show error
             self.save_error = f"Error saving deployment: {e}"
@@ -441,6 +468,10 @@ class DeploymentEditApp(App[DeploymentResponse | None]):
         """Handle cancel message from form widget"""
         self.exit(None)
 
+    def on_monitor_close_message(self, _: MonitorCloseMessage) -> None:
+        """Handle close from embedded monitor by exiting with saved deployment."""
+        self.exit(self.saved_deployment)
+
 
 def edit_deployment_form(
     deployment: DeploymentResponse,
@@ -467,6 +498,7 @@ def _initialize_deployment_data() -> DeploymentForm:
     git_ref: str | None = None
     secrets: dict[str, str] = {}
     name: str | None = None
+    config_file_path: str | None = None
     if is_git_repo():
         seen = set[str]()
         remotes = list_remotes()
@@ -482,22 +514,25 @@ def _initialize_deployment_data() -> DeploymentForm:
         if preferred_origin:
             repo_url = preferred_origin[0]
         git_ref = get_current_branch()
+        root = get_git_root()
+        if root != Path.cwd():
+            config_file_path = str(Path.cwd().relative_to(root))
+
     if Path(".env").exists():
         secrets = load_env_secrets_from_string(Path(".env").read_text())
-    for f in os.listdir("."):
-        if f.endswith(".yml") or f.endswith(".yaml"):
-            try:
-                config = DeploymentConfig.from_yaml(Path(f))
-                name = config.name
-                break
-            except Exception:
-                pass
+    try:
+        config = read_deployment_config(Path("."), Path("."))
+        if config.name != DEFAULT_DEPLOYMENT_NAME:
+            name = config.name
+    except Exception:
+        pass
 
     form = DeploymentForm(
         name=name or "",
         repo_url=repo_url or "",
         git_ref=git_ref or "main",
         secrets=secrets,
+        deployment_file_path=config_file_path or "",
     )
     return form
 

llama_deploy/cli/textual/deployment_help.py

@@ -36,8 +36,8 @@ class DeploymentHelpWidget(Widget):
                 [b]Git Ref[/b]
                 The git ref to deploy. This can be a branch, tag, or commit hash. If this is a branch, after deploying, run a `[slategrey reverse]llamactl deploy refresh[/]` to update the deployment to the latest git ref after you make updates.
                 
-                [b]Deployment File[/b]
-                The `[slategrey reverse]llama_deploy.yaml[/]` file to use for the deployment. This is a yaml file that contains the configuration for how to serve the deployment.
+                [b]Config File[/b]
+                Path to a directory or file containing a `[slategrey reverse]pyproject.toml[/]` or `[slategrey reverse]llama_deploy.yaml[/]` containing the llama deploy configuration. Only necessary if you have the configuration not at the root of the repo, or you have an unconventional configuration file.
                 
                 [b]Secrets[/b]
                 Secrets to add as environment variables to the deployment. e.g. to access a database or an API. Supports adding in `[slategrey reverse].env[/]` file format.

llama_deploy/cli/textual/deployment_monitor.py

@@ -0,0 +1,429 @@
+"""Textual component to monitor a deployment and stream its logs."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import threading
+import time
+from pathlib import Path
+from typing import Iterator
+
+from llama_deploy.cli.client import Closer
+from llama_deploy.cli.client import get_project_client as get_client
+from llama_deploy.core.schema.base import LogEvent
+from llama_deploy.core.schema.deployments import DeploymentResponse
+from rich.text import Text
+from textual.app import App, ComposeResult
+from textual.containers import Container, HorizontalGroup, Widget
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widgets import Button, RichLog, Static
+
+
+class DeploymentMonitorWidget(Widget):
+    """Widget that fetches deployment details once and streams logs.
+
+    Notes:
+    - Status is polled periodically
+    - Log stream is started with init container logs included on first connect
+    - If the stream ends or hangs, we reconnect with duration-aware backoff
+    """
+
+    DEFAULT_CSS = """
+	DeploymentMonitorWidget {
+		layout: vertical;
+		width: 1fr;
+		height: 1fr;
+	}
+
+	.monitor-container {
+		width: 1fr;
+		height: 1fr;
+		padding: 0;
+		margin: 0;
+	}
+
+	.details-grid {
+		layout: grid;
+		grid-size: 2;
+		grid-columns: auto 1fr;
+		grid-gutter: 0 1;
+		grid-rows: auto;
+		height: auto;
+		width: 1fr;
+	}
+
+	.log-header {
+		margin-top: 1;
+	}
+
+
+	"""
+
+    deployment_id: str
+    deployment = reactive[DeploymentResponse | None](None, recompose=False)
+    error_message = reactive("", recompose=False)
+    wrap_enabled = reactive(False, recompose=False)
+    autoscroll_enabled = reactive(True, recompose=False)
+    stream_closer: Closer | None = None
+
+    def __init__(self, deployment_id: str) -> None:
+        super().__init__()
+        self.deployment_id = deployment_id
+        self._stop_stream = threading.Event()
+        # Persist content written to the RichLog across recomposes
+        self._log_buffer: list[Text] = []
+
+    def on_mount(self) -> None:
+        # Kick off initial fetch and start logs stream in background
+        self.run_worker(self._fetch_deployment(), exclusive=True)
+        self.run_worker(self._stream_logs, exclusive=False, thread=True)
+        # Start periodic polling of deployment status
+        self.run_worker(self._poll_deployment_status(), exclusive=False)
+
+    def compose(self) -> ComposeResult:
+        yield Static("Deployment Status", classes="primary-message")
+        yield Static("", classes="error-message", id="error_message")
+
+        # Single-line status bar with colored icon and deployment ID
+        with HorizontalGroup(classes="mb-1"):
+            yield Static(
+                self._render_status_line(), classes="status-line", id="status_line"
+            )
+
+        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,
+        )
+
+        with HorizontalGroup(classes="button-row"):
+            wrap_label = "Wrap: On" if self.wrap_enabled else "Wrap: Off"
+            auto_label = (
+                "Auto-scroll: On" if self.autoscroll_enabled else "Auto-scroll: Off"
+            )
+            yield Button(wrap_label, id="toggle_wrap", variant="default", compact=True)
+            yield Button(
+                auto_label, id="toggle_autoscroll", variant="default", compact=True
+            )
+            yield Button("Copy", id="copy_log", variant="default", compact=True)
+            yield Button("Close", id="close", variant="default", compact=True)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "close":
+            # Signal parent app to close
+            self.post_message(MonitorCloseMessage())
+        elif event.button.id == "toggle_wrap":
+            self.wrap_enabled = not self.wrap_enabled
+        elif event.button.id == "toggle_autoscroll":
+            self.autoscroll_enabled = not self.autoscroll_enabled
+        elif event.button.id == "copy_log":
+            txt = "\n".join([str(x) for x in self._log_buffer])
+            self.app.copy_to_clipboard(txt)
+
+    async def _fetch_deployment(self) -> None:
+        try:
+            client = get_client()
+            self.deployment = client.get_deployment(self.deployment_id)
+            # Clear any previous error on success
+            self.error_message = ""
+        except Exception as e:  # pragma: no cover - network errors
+            self.error_message = f"Failed to fetch deployment: {e}"
+
+    def _stream_logs(self) -> None:
+        """Consume the blocking log iterator in a single worker thread.
+
+        Cooperative cancellation uses `self._stop_stream` to exit cleanly.
+        """
+        client = get_client()
+
+        def _sleep_with_cancel(total_seconds: float) -> None:
+            step = 0.2
+            remaining = total_seconds
+            while remaining > 0 and not self._stop_stream.is_set():
+                time.sleep(min(step, remaining))
+                remaining -= step
+
+        base_backoff_seconds = 0.2
+        backoff_seconds = base_backoff_seconds
+        max_backoff_seconds = 30.0
+
+        while not self._stop_stream.is_set():
+            try:
+                connect_started_at = time.monotonic()
+                closer, stream = client.stream_deployment_logs(
+                    self.deployment_id,
+                    include_init_containers=True,
+                )
+                # On any (re)connect, clear existing content
+                self.app.call_from_thread(self._reset_log_view_for_reconnect)
+
+                buffered_stream = _buffer_log_lines(stream)
+
+                def close_stream():
+                    try:
+                        closer()
+                    except Exception:
+                        pass
+
+                self.stream_closer = close_stream
+                # Stream connected; consume until end
+                for events in buffered_stream:
+                    if self._stop_stream.is_set():
+                        break
+                    # Marshal UI updates back to the main thread via the App
+                    self.app.call_from_thread(self._handle_log_events, events)
+                if self._stop_stream.is_set():
+                    break
+                # Stream ended without explicit error; attempt reconnect
+                self.app.call_from_thread(
+                    self._set_error_message, "Log stream disconnected. Reconnecting..."
+                )
+            except Exception as e:
+                if self._stop_stream.is_set():
+                    break
+                # Surface the error to the UI and attempt reconnect with backoff
+                self.app.call_from_thread(
+                    self._set_error_message, f"Log stream failed: {e}. Reconnecting..."
+                )
+
+            # Duration-aware backoff: subtract how long the last connection lived
+            connection_lifetime = 0.0
+            try:
+                connection_lifetime = max(0.0, time.monotonic() - connect_started_at)
+            except Exception:
+                connection_lifetime = 0.0
+
+            # If the connection lived longer than the current backoff window,
+            # reset to base so the next reconnect is immediate.
+            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:
+                _sleep_with_cancel(delay)
+
+    def _reset_log_view_for_reconnect(self) -> None:
+        """Clear UI and buffers so new stream replaces previous content."""
+        try:
+            log_widget = self.query_one("#log_view", RichLog)
+        except Exception:
+            log_widget = None
+        if log_widget is not None:
+            log_widget.clear()
+
+    def _set_error_message(self, message: str) -> None:
+        self.error_message = message
+
+    def _handle_log_events(self, events: list[LogEvent]) -> None:
+        def to_text(event: LogEvent) -> Text:
+            txt = Text()
+            txt.append(
+                f"[{event.container}] ", style=self._container_style(event.container)
+            )
+            txt.append(event.text)
+            return txt
+
+        texts = [to_text(event) for event in events]
+        if not texts:
+            return
+
+        log_widget = self.query_one("#log_view", RichLog)
+        for text in texts:
+            log_widget.write(text)
+            self._log_buffer.append(text)
+        # Clear any previous error once we successfully receive logs
+        if self.error_message:
+            self.error_message = ""
+
+    def _container_style(self, container_name: str) -> str:
+        palette = [
+            "bold magenta",
+            "bold cyan",
+            "bold blue",
+            "bold green",
+            "bold red",
+            "bold bright_blue",
+        ]
+        # Stable hash to pick a color per container name
+        h = int(hashlib.sha256(container_name.encode()).hexdigest(), 16)
+        return palette[h % len(palette)]
+
+    def _status_icon_and_style(self, phase: str) -> tuple[str, str]:
+        # Map deployment phase to a colored icon
+        phase = phase or "-"
+        green = "bold green"
+        yellow = "bold yellow"
+        red = "bold red"
+        gray = "grey50"
+        if phase in {"Running", "Succeeded"}:
+            return "●", green
+        if phase in {"Pending", "Syncing", "RollingOut"}:
+            return "●", yellow
+        if phase in {"Failed", "RolloutFailed"}:
+            return "●", red
+        return "●", gray
+
+    def _render_status_line(self) -> Text:
+        phase = self.deployment.status if self.deployment else "-"
+        icon, style = self._status_icon_and_style(phase)
+        line = Text()
+        line.append(icon, style=style)
+        line.append(" ")
+        line.append(f"Status: {phase} — Deployment ID: {self.deployment_id or '-'}")
+        return line
+
+    def on_unmount(self) -> None:
+        # Attempt to stop the streaming loop
+        self._stop_stream.set()
+        if self.stream_closer is not None:
+            self.stream_closer()
+            self.stream_closer = None
+
+    # Reactive watchers to update widgets in place instead of recomposing
+    def watch_error_message(self, message: str) -> None:
+        try:
+            widget = self.query_one("#error_message", Static)
+        except Exception:
+            return
+        widget.update(message)
+        widget.display = bool(message)
+
+    def watch_deployment(self, deployment: DeploymentResponse | None) -> None:
+        if deployment is None:
+            return
+        phase = deployment.status or "-"
+        last = getattr(self, "_last_phase", None)
+        if last == phase:
+            return
+        self._last_phase = phase
+        try:
+            widget = self.query_one("#status_line", Static)
+        except Exception:
+            return
+        widget.update(self._render_status_line())
+
+    def watch_wrap_enabled(self, enabled: bool) -> None:
+        try:
+            log_widget = self.query_one("#log_view", RichLog)
+            log_widget.wrap = enabled
+            # Clear existing lines; new wrap mode will apply to subsequent events
+            log_widget.clear()
+            for text in self._log_buffer:
+                log_widget.write(text)
+        except Exception:
+            pass
+        try:
+            btn = self.query_one("#toggle_wrap", Button)
+            btn.label = "Wrap: On" if enabled else "Wrap: Off"
+        except Exception:
+            pass
+
+    def watch_autoscroll_enabled(self, enabled: bool) -> None:
+        try:
+            log_widget = self.query_one("#log_view", RichLog)
+            log_widget.auto_scroll = enabled
+        except Exception:
+            pass
+        try:
+            btn = self.query_one("#toggle_autoscroll", Button)
+            btn.label = "Auto-scroll: On" if enabled else "Auto-scroll: Off"
+        except Exception:
+            pass
+
+    async def _poll_deployment_status(self) -> None:
+        """Periodically refresh deployment status to reflect updates in the UI."""
+        client = get_client()
+        while not self._stop_stream.is_set():
+            try:
+                self.deployment = client.get_deployment(self.deployment_id)
+                # Clear any previous error on success
+                if self.error_message:
+                    self.error_message = ""
+            except Exception as e:  # pragma: no cover - network errors
+                # Non-fatal; will try again on next interval
+                self.error_message = f"Failed to refresh status: {e}"
+            await asyncio.sleep(5)
+
+
+class MonitorCloseMessage(Message):
+    pass
+
+
+class DeploymentMonitorApp(App[None]):
+    """Standalone app wrapper around the monitor widget.
+
+    This allows easy reuse in other flows by embedding the widget.
+    """
+
+    CSS_PATH = Path(__file__).parent / "styles.tcss"
+
+    def __init__(self, deployment_id: str) -> None:
+        super().__init__()
+        self.deployment_id = deployment_id
+
+    def on_mount(self) -> None:
+        self.theme = "tokyo-night"
+
+    def compose(self) -> ComposeResult:
+        with Container():
+            yield DeploymentMonitorWidget(self.deployment_id)
+
+    def on_monitor_close_message(self, _: MonitorCloseMessage) -> None:
+        self.exit(None)
+
+    def on_key(self, event) -> None:
+        # Support Ctrl+C to exit, consistent with other screens and terminals
+        if event.key == "ctrl+c":
+            self.exit(None)
+
+
+def monitor_deployment_screen(deployment_id: str) -> None:
+    """Launch the standalone deployment monitor screen."""
+    app = DeploymentMonitorApp(deployment_id)
+    app.run()
+
+
+def _buffer_log_lines(iter: Iterator[LogEvent]) -> Iterator[list[LogEvent]]:
+    """Batch log events into small lists using a background reader.
+
+    This reduces UI churn while still reacting quickly. On shutdown we
+    absorb stream read errors that are expected when the connection is
+    closed from another thread.
+    """
+    buffer: list[LogEvent] = []
+    bg_error: Exception | None = None
+    done = threading.Event()
+
+    def pump() -> None:
+        nonlocal bg_error
+        try:
+            for event in iter:
+                buffer.append(event)
+        except Exception as e:
+            bg_error = e
+        finally:
+            done.set()
+
+    t = threading.Thread(target=pump, daemon=True)
+    t.start()
+    try:
+        while not done.is_set():
+            if buffer:
+                # Yield a snapshot and clear in-place to avoid reallocating list
+                yield list(buffer)
+                buffer.clear()
+            time.sleep(0.5)
+        if bg_error is not None:
+            raise bg_error
+    finally:
+        try:
+            t.join(timeout=0.1)
+        except Exception:
+            pass