llamactl 0.3.0a7__tar.gz → 0.3.0a9__tar.gz

{llamactl-0.3.0a7 → llamactl-0.3.0a9}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.3
 Name: llamactl
-Version: 0.3.0a7
+Version: 0.3.0a9
 Summary: A command-line interface for managing LlamaDeploy projects and deployments
 Author: Adrian Lyjak
 Author-email: Adrian Lyjak <adrianlyjak@gmail.com>
 License: MIT
-Requires-Dist: llama-deploy-core>=0.3.0a7,<0.4.0
-Requires-Dist: llama-deploy-appserver>=0.3.0a7,<0.4.0
+Requires-Dist: llama-deploy-core>=0.3.0a9,<0.4.0
+Requires-Dist: llama-deploy-appserver>=0.3.0a9,<0.4.0
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: questionary>=2.0.0
 Requires-Dist: click>=8.2.1
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: tenacity>=9.1.2
-Requires-Dist: textual>=4.0.0
+Requires-Dist: textual>=5.3.0
 Requires-Dist: aiohttp>=3.12.14
 Requires-Dist: copier>=9.9.0
 Requires-Python: >=3.12, <4

{llamactl-0.3.0a7 → llamactl-0.3.0a9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "llamactl"
-version = "0.3.0a7"
+version = "0.3.0a9"
 description = "A command-line interface for managing LlamaDeploy projects and deployments"
 readme = "README.md"
 license = { text = "MIT" }
@@ -9,17 +9,17 @@ authors = [
 ]
 requires-python = ">=3.12, <4"
 dependencies = [
-    "llama-deploy-core>=0.3.0a7,<0.4.0",
-    "llama-deploy-appserver>=0.3.0a7,<0.4.0",
+    "llama-deploy-core>=0.3.0a9,<0.4.0",
+    "llama-deploy-appserver>=0.3.0a9,<0.4.0",
     "httpx>=0.24.0",
     "rich>=13.0.0",
     "questionary>=2.0.0",
     "click>=8.2.1",
     "python-dotenv>=1.0.0",
     "tenacity>=9.1.2",
-    "textual>=4.0.0",
+    "textual>=5.3.0",
     "aiohttp>=3.12.14",
-    "copier>=9.9.0"
+    "copier>=9.9.0",
 ]
 
 [project.scripts]

{llamactl-0.3.0a7 → llamactl-0.3.0a9}/src/llama_deploy/cli/__init__.py

@@ -1,4 +1,5 @@
 from llama_deploy.cli.commands.deployment import deployments
+from llama_deploy.cli.commands.init import init
 from llama_deploy.cli.commands.profile import profiles
 from llama_deploy.cli.commands.serve import serve
 
@@ -10,7 +11,7 @@ def main() -> None:
     app()
 
 
-__all__ = ["app", "deployments", "profiles", "serve"]
+__all__ = ["app", "deployments", "profiles", "serve", "init"]
 
 
 if __name__ == "__main__":

{llamactl-0.3.0a7 → llamactl-0.3.0a9}/src/llama_deploy/cli/client.py

@@ -1,6 +1,8 @@
-from typing import List
+import contextlib
+from typing import Iterator, List
 
 import httpx
+from llama_deploy.core.schema.base import LogEvent
 from llama_deploy.core.schema.deployments import (
     DeploymentCreate,
     DeploymentResponse,
@@ -17,19 +19,24 @@ from rich.console import Console
 from .config import config_manager
 
 
+class ClientError(Exception):
+    """Base class for client errors."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
 class BaseClient:
     def __init__(self, base_url: str, console: Console) -> None:
         self.base_url = base_url.rstrip("/")
         self.console = console
         self.client = httpx.Client(
-            base_url=self.base_url, event_hooks={"response": [self._handle_response]}
+            base_url=self.base_url,
+            event_hooks={"response": [self._handle_response]},
         )
+        self.hookless_client = httpx.Client(base_url=self.base_url)
 
     def _handle_response(self, response: httpx.Response) -> None:
-        if "X-Warning" in response.headers:
-            self.console.print(
-                f"[yellow]Warning: {response.headers['X-Warning']}[/yellow]"
-            )
         try:
             response.raise_for_status()
         except httpx.HTTPStatusError as e:
@@ -42,9 +49,9 @@ class BaseClient:
                     error_message = str(error_data)
             except (ValueError, KeyError):
                 error_message = e.response.text
-            raise Exception(f"HTTP {e.response.status_code}: {error_message}") from e
+            raise ClientError(f"HTTP {e.response.status_code}: {error_message}") from e
         except httpx.RequestError as e:
-            raise Exception(f"Request failed: {e}") from e
+            raise ClientError(f"Request failed: {e}") from e
 
 
 class ControlPlaneClient(BaseClient):
@@ -59,7 +66,7 @@ class ControlPlaneClient(BaseClient):
         return response.json()
 
     def list_projects(self) -> List[ProjectSummary]:
-        response = self.client.get("/projects/")
+        response = self.client.get("/api/v1beta1/deployments/list-projects")
         projects_response = ProjectsListResponse.model_validate(response.json())
         return [project for project in projects_response.projects]
 
@@ -95,25 +102,37 @@ class ProjectClient(BaseClient):
         self.project_id = project_id
 
     def list_deployments(self) -> List[DeploymentResponse]:
-        response = self.client.get(f"/{self.project_id}/deployments/")
+        response = self.client.get(
+            "/api/v1beta1/deployments",
+            params={"project_id": self.project_id},
+        )
         deployments_response = DeploymentsListResponse.model_validate(response.json())
         return [deployment for deployment in deployments_response.deployments]
 
-    def get_deployment(self, deployment_id: str) -> DeploymentResponse:
-        response = self.client.get(f"/{self.project_id}/deployments/{deployment_id}")
+    def get_deployment(
+        self, deployment_id: str, include_events: bool = False
+    ) -> DeploymentResponse:
+        response = self.client.get(
+            f"/api/v1beta1/deployments/{deployment_id}",
+            params={"project_id": self.project_id, "include_events": include_events},
+        )
         return DeploymentResponse.model_validate(response.json())
 
     def create_deployment(
         self, deployment_data: DeploymentCreate
     ) -> DeploymentResponse:
         response = self.client.post(
-            f"/{self.project_id}/deployments/",
+            "/api/v1beta1/deployments",
+            params={"project_id": self.project_id},
             json=deployment_data.model_dump(exclude_none=True),
         )
         return DeploymentResponse.model_validate(response.json())
 
     def delete_deployment(self, deployment_id: str) -> None:
-        self.client.delete(f"/{self.project_id}/deployments/{deployment_id}")
+        self.client.delete(
+            f"/api/v1beta1/deployments/{deployment_id}",
+            params={"project_id": self.project_id},
+        )
 
     def update_deployment(
         self,
@@ -121,7 +140,8 @@ class ProjectClient(BaseClient):
         update_data: DeploymentUpdate,
     ) -> DeploymentResponse:
         response = self.client.patch(
-            f"/{self.project_id}/deployments/{deployment_id}",
+            f"/api/v1beta1/deployments/{deployment_id}",
+            params={"project_id": self.project_id},
             json=update_data.model_dump(),
         )
         return DeploymentResponse.model_validate(response.json())
@@ -133,7 +153,8 @@ class ProjectClient(BaseClient):
         pat: str | None = None,
     ) -> RepositoryValidationResponse:
         response = self.client.post(
-            f"/{self.project_id}/deployments/validate-repository",
+            "/api/v1beta1/deployments/validate-repository",
+            params={"project_id": self.project_id},
             json=RepositoryValidationRequest(
                 repository_url=repo_url,
                 deployment_id=deployment_id,
@@ -142,6 +163,81 @@ class ProjectClient(BaseClient):
         )
         return RepositoryValidationResponse.model_validate(response.json())
 
+    def stream_deployment_logs(
+        self,
+        deployment_id: str,
+        *,
+        include_init_containers: bool = False,
+        since_seconds: int | None = None,
+        tail_lines: int | None = None,
+    ) -> tuple["Closer", Iterator[LogEvent]]:
+        """Stream logs as LogEvent items from the control plane using SSE.
+
+        This yields `LogEvent` models until the stream ends (e.g. rollout).
+        """
+        # Use a separate client without response hooks so we don't consume the stream
+
+        params = {
+            "project_id": self.project_id,
+            "include_init_containers": include_init_containers,
+        }
+        if since_seconds is not None:
+            params["since_seconds"] = since_seconds
+        if tail_lines is not None:
+            params["tail_lines"] = tail_lines
+
+        url = f"/api/v1beta1/deployments/{deployment_id}/logs"
+        headers = {"Accept": "text/event-stream"}
+
+        stack = contextlib.ExitStack()
+        response = stack.enter_context(
+            self.hookless_client.stream(
+                "GET", url, params=params, headers=headers, timeout=None
+            )
+        )
+        try:
+            response.raise_for_status()
+        except Exception:
+            stack.close()
+            raise
+
+        return stack.close, _iterate_log_stream(response, stack.close)
+
+
+def _iterate_log_stream(
+    response: httpx.Response, closer: "Closer"
+) -> Iterator[LogEvent]:
+    event_name: str | None = None
+    data_lines: list[str] = []
+
+    try:
+        for line in response.iter_lines():
+            if line is None:
+                continue
+            line = line.decode() if isinstance(line, (bytes, bytearray)) else line
+            print("got line", line)
+            if line.startswith("event:"):
+                event_name = line[len("event:") :].strip()
+            elif line.startswith("data:"):
+                data_lines.append(line[len("data:") :].lstrip())
+            elif line.strip() == "":
+                if event_name == "log" and data_lines:
+                    data_str = "\n".join(data_lines)
+                    try:
+                        yield LogEvent.model_validate_json(data_str)
+                        print("yielded log event", data_str)
+                    except Exception:
+                        # If parsing fails, skip malformed event
+                        pass
+                # reset for next event
+                event_name = None
+                data_lines = []
+    finally:
+        try:
+            closer()
+        except Exception:
+            pass
+
 
 def get_control_plane_client(base_url: str | None = None) -> ControlPlaneClient:
     console = Console()
@@ -174,3 +270,6 @@ def get_project_client(
     if not resolved_project_id:
         raise ValueError("Project ID is required")
     return ProjectClient(resolved_base_url, resolved_project_id, console)
+
+
+type Closer = callable[tuple[()], None]

{llamactl-0.3.0a7 → llamactl-0.3.0a9}/src/llama_deploy/cli/commands/deployment.py

@@ -19,6 +19,7 @@ from ..interactive_prompts.utils import (
 )
 from ..options import global_options
 from ..textual.deployment_form import create_deployment_form, edit_deployment_form
+from ..textual.deployment_monitor import monitor_deployment_screen
 
 
 @app.group(
@@ -88,7 +89,12 @@ def list_deployments() -> None:
 @deployments.command("get")
 @global_options
 @click.argument("deployment_id", required=False)
-def get_deployment(deployment_id: str | None) -> None:
+@click.option(
+    "--non-interactive",
+    is_flag=True,
+    help="Do not open a live monitor screen showing status and streaming logs",
+)
+def get_deployment(deployment_id: str | None, non_interactive: bool) -> None:
     """Get details of a specific deployment"""
     try:
         client = get_project_client()
@@ -98,6 +104,10 @@ def get_deployment(deployment_id: str | None) -> None:
             rprint("[yellow]No deployment selected[/yellow]")
             return
 
+        if not non_interactive:
+            monitor_deployment_screen(deployment_id)
+            return
+
         deployment = client.get_deployment(deployment_id)
 
         table = Table(title=f"Deployment: {deployment.name}")
@@ -143,7 +153,7 @@ def create_deployment(
     git_ref: str | None,
     personal_access_token: str | None,
 ) -> None:
-    """Create a new deployment"""
+    """Interactively create a new deployment"""
 
     # Use interactive creation
     deployment_form = create_deployment_form()
@@ -214,11 +224,11 @@ def edit_deployment(deployment_id: str | None) -> None:
         raise click.Abort()
 
 
-@deployments.command("refresh")
+@deployments.command("update")
 @global_options
 @click.argument("deployment_id", required=False)
 def refresh_deployment(deployment_id: str | None) -> None:
-    """Refresh a deployment with the latest code from its git reference"""
+    """Update the deployment, pulling the latest code from it's branch"""
     try:
         client = get_project_client()
 

llamactl-0.3.0a9/src/llama_deploy/cli/commands/init.py

@@ -0,0 +1,210 @@
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+import copier
+import questionary
+from click.exceptions import Exit
+from llama_deploy.cli.app import app
+from llama_deploy.cli.options import global_options
+from rich import print as rprint
+
+
+@dataclass
+class TemplateOption:
+    id: str
+    name: str
+    description: str
+    git_url: str
+
+
+options = [
+    TemplateOption(
+        id="basic-ui",
+        name="Basic UI",
+        description="A basic starter workflow with a React Vite UI",
+        git_url="https://github.com/adrianlyjak/qs",
+    ),
+    TemplateOption(
+        id="extraction-review",
+        name="Extraction Agent with Review UI",
+        description="Extract data from documents using a custom schema and Llama Cloud. Includes a UI to review and correct the results",
+        git_url="https://github.com/run-llama/template-workflow-data-extraction",
+    ),
+]
+
+
+@app.command()
+@click.option(
+    "--update",
+    is_flag=True,
+    help="Instead of creating a new app, update the current app to the latest version. Other options will be ignored.",
+)
+@click.option(
+    "--template",
+    type=click.Choice([o.id for o in options]),
+    help="The template to use for the new app",
+)
+@click.option(
+    "--dir",
+    help="The directory to create the new app in",
+    type=click.Path(
+        file_okay=False, dir_okay=True, writable=True, resolve_path=True, path_type=Path
+    ),
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Force overwrite the directory if it exists",
+)
+@global_options
+def init(
+    update: bool,
+    template: str | None,
+    dir: Path | None,
+    force: bool,
+) -> None:
+    """Create a new app repository from a template"""
+    if update:
+        _update()
+    else:
+        _create(template, dir, force)
+
+
+def _create(template: str | None, dir: Path | None, force: bool) -> None:
+    if template is None:
+        template = questionary.select(
+            "Choose a template",
+            choices=[
+                questionary.Choice(title=o.name, value=o.id, description=o.description)
+                for o in options
+            ],
+        ).ask()
+    if template is None:
+        rprint("No template selected")
+        raise Exit(1)
+    if dir is None:
+        dir_str = questionary.text(
+            "Enter the directory to create the new app in", default=template
+        ).ask()
+        if not dir_str:
+            rprint("No directory provided")
+            raise Exit(1)
+        dir = Path(dir_str)
+    resolved_template = next((o for o in options if o.id == template), None)
+    if resolved_template is None:
+        rprint(f"Template {template} not found")
+        raise Exit(1)
+    if dir.exists():
+        is_ok = (
+            force
+            or questionary.confirm("Directory exists. Overwrite?", default=False).ask()
+        )
+        if not is_ok:
+            raise Exit(1)
+        else:
+            shutil.rmtree(dir, ignore_errors=True)
+    copier.run_copy(
+        resolved_template.git_url,
+        dir,
+        quiet=True,
+    )
+    # Initialize git repository if git is available
+    is_git_initialized = False
+    try:
+        subprocess.run(["git", "--version"], check=True, capture_output=True)
+
+        # Change to the new directory and initialize git repo
+        original_cwd = Path.cwd()
+        os.chdir(dir)
+
+        try:
+            subprocess.run(["git", "init"], check=True, capture_output=True)
+            subprocess.run(["git", "add", "."], check=True, capture_output=True)
+            subprocess.run(
+                ["git", "commit", "-m", "Initial commit"],
+                check=True,
+                capture_output=True,
+            )
+            is_git_initialized = True
+        finally:
+            os.chdir(original_cwd)
+
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # Git not available or failed - continue without git initialization
+        pass
+
+    rprint(
+        f"Successfully created [blue]{dir}[/] using the [blue]{resolved_template.name}[/] template! 🎉 🦙 💾"
+    )
+    rprint("")
+    rprint("[bold]To run locally:[/]")
+    rprint(f"    [orange3]cd[/] {dir}")
+    rprint("    [orange3]uvx[/] llamactl serve")
+    rprint("")
+    rprint("[bold]To deploy:[/]")
+    if not is_git_initialized:
+        rprint("    [orange3]git[/] init")
+        rprint("    [orange3]git[/] add .")
+        rprint("    [orange3]git[/] commit -m 'Initial commit'")
+        rprint("")
+    rprint("[dim](Create a new repo and add it as a remote)[/]")
+    rprint("")
+    rprint("    [orange3]git[/] remote add origin <your-repo-url>")
+    rprint("    [orange3]git[/] push -u origin main")
+    rprint("")
+    # rprint("  [orange3]uvx[/] llamactl login")
+    rprint("    [orange3]uvx[/] llamactl deploy")
+    rprint("")
+
+
+def _update():
+    """Update the app to the latest version"""
+    try:
+        copier.run_update(
+            overwrite=True,
+            skip_answered=True,
+            quiet=True,
+        )
+    except copier.UserMessageError as e:
+        rprint(f"{e}")
+        raise Exit(1)
+
+    # Check git status and warn about conflicts
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.stdout.strip():
+            conflicted_files = []
+            modified_files = []
+
+            for line in result.stdout.strip().split("\n"):
+                status = line[:2]
+                filename = line[3:]
+
+                if "UU" in status or "AA" in status or "DD" in status:
+                    conflicted_files.append(filename)
+                elif status.strip():
+                    modified_files.append(filename)
+
+            if conflicted_files:
+                rprint("")
+                rprint("⚠️  [bold]Files with conflicts detected:[/]")
+                for file in conflicted_files:
+                    rprint(f"    {file}")
+                rprint("")
+                rprint(
+                    "Please manually resolve conflicts with a merge editor before proceeding."
+                )
+
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # Git not available or not in a git repo - continue silently
+        pass

{llamactl-0.3.0a7 → llamactl-0.3.0a9}/src/llama_deploy/cli/textual/deployment_form.py

@@ -13,6 +13,10 @@ 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,
@@ -334,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__()
@@ -350,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":
@@ -368,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)
 
@@ -432,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}"
@@ -447,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,

llamactl-0.3.0a9/src/llama_deploy/cli/textual/deployment_monitor.py

@@ -0,0 +1,474 @@
+"""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.content import Content
+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;
+	}
+
+    .status-line .status-main {
+        width: auto;
+    }
+
+    .status-line .status-right {
+        width: 1fr;
+        text-align: right;
+        min-width: 12;
+    }
+
+
+	"""
+
+    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="status-line"):
+            yield Static(
+                self._render_status_line(), classes="status-main", id="status_line"
+            )
+            yield Static("", classes="status-right", id="last_event_status")
+        yield Static("", classes="last-event mb-1", id="last_event_details")
+
+        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, include_events=True
+            )
+            # 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 "Unknown"
+        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 _render_last_event_details(self) -> Content:
+        if not self.deployment or not self.deployment.events:
+            return Content()
+        latest = self.deployment.events[-1]
+        txt = Text(f"  {latest.message}", style="dim")
+        return Content.from_rich_text(txt)
+
+    def _render_last_event_status(self) -> Content:
+        if not self.deployment or not self.deployment.events:
+            return Content()
+        txt = Text()
+        # Pick the most recent by last_timestamp
+        latest = self.deployment.events[-1]
+        ts = None
+        ts = (latest.last_timestamp or latest.first_timestamp).strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        parts: list[str] = []
+        if latest.type:
+            parts.append(latest.type)
+        if latest.reason:
+            parts.append(latest.reason)
+        kind = "/".join(parts) if parts else None
+        if kind:
+            txt.append(f"{kind} ", style="medium_purple3")
+        txt.append(f"{ts}", style="dim")
+        return Content.from_rich_text(txt)
+
+    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
+
+        widget = self.query_one("#status_line", Static)
+        ev_widget = self.query_one("#last_event_status", Static)
+        ev_details_widget = self.query_one("#last_event_details", Static)
+
+        widget.update(self._render_status_line())
+        # Update last event line
+        ev_widget.update(self._render_last_event_status())
+        ev_details_widget.update(self._render_last_event_details())
+        ev_details_widget.display = bool(self.deployment and self.deployment.events)
+
+    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, include_events=True
+                )
+                # 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