glaip-sdk 0.7.8__py3-none-any.whl → 0.7.10__py3-none-any.whl

glaip_sdk/cli/slash/tui/remote_runs_app.py

@@ -19,12 +19,16 @@ from typing import Any
 from rich.text import Text
 from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.containers import Container, Horizontal
+from textual.containers import Container, Horizontal, Vertical
+from textual.coordinate import Coordinate
 from textual.reactive import ReactiveError
 from textual.screen import ModalScreen
 from textual.widgets import DataTable, Footer, Header, LoadingIndicator, RichLog, Static
 
+from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter
+from glaip_sdk.cli.slash.tui.context import TUIContext
 from glaip_sdk.cli.slash.tui.loading import hide_loading_indicator, show_loading_indicator
+from glaip_sdk.cli.slash.tui.toast import ClipboardToastMixin, Toast, ToastBus, ToastHandlerMixin
 
 logger = logging.getLogger(__name__)
 
@@ -50,6 +54,7 @@ def run_remote_runs_textual(
     *,
     agent_name: str | None = None,
     agent_id: str | None = None,
+    ctx: TUIContext | None = None,
 ) -> tuple[int, int, int]:
     """Launch the Textual application and return the final pagination state.
 
@@ -59,6 +64,7 @@ def run_remote_runs_textual(
         callbacks: Data provider callback bundle.
         agent_name: Optional agent name for display purposes.
         agent_id: Optional agent ID for display purposes.
+        ctx: Shared TUI context.
 
     Returns:
         Tuple of (page, limit, cursor_index) after the UI exits.
@@ -69,15 +75,27 @@ def run_remote_runs_textual(
         callbacks,
         agent_name=agent_name,
         agent_id=agent_id,
+        ctx=ctx,
     )
     app.run()
     current_page = getattr(app, "current_page", initial_page)
     return current_page.page, current_page.limit, app.cursor_index
 
 
-class RunDetailScreen(ModalScreen[None]):
+class RunDetailScreen(ToastHandlerMixin, ClipboardToastMixin, ModalScreen[None]):
     """Modal screen displaying run metadata and output timeline."""
 
+    CSS = """
+    Screen { layout: vertical; layers: base toasts; }
+    #toast-container {
+        width: 100%;
+        height: auto;
+        dock: top;
+        align: right top;
+        layer: toasts;
+    }
+    """
+
     BINDINGS = [
         Binding("escape", "dismiss", "Close", priority=True),
         Binding("q", "dismiss_modal", "Close", priority=True),
@@ -85,14 +103,24 @@ class RunDetailScreen(ModalScreen[None]):
         Binding("down", "scroll_down", "Down"),
         Binding("pageup", "page_up", "PgUp"),
         Binding("pagedown", "page_down", "PgDn"),
+        Binding("c", "copy_run_id", "Copy ID"),
+        Binding("C", "copy_detail_json", "Copy JSON"),
         Binding("e", "export_detail", "Export"),
     ]
 
-    def __init__(self, detail: Any, on_export: Callable[[Any], None] | None = None):
+    def __init__(
+        self,
+        detail: Any,
+        on_export: Callable[[Any], None] | None = None,
+        ctx: TUIContext | None = None,
+    ) -> None:
         """Initialize the run detail screen."""
         super().__init__()
         self.detail = detail
         self._on_export = on_export
+        self._ctx = ctx
+        self._clipboard: ClipboardAdapter | None = None
+        self._local_toasts: ToastBus | None = None
 
     def compose(self) -> ComposeResult:
         """Render metadata and events."""
@@ -116,14 +144,17 @@ class RunDetailScreen(ModalScreen[None]):
         duration = self.detail.duration_formatted() if getattr(self.detail, "duration_formatted", None) else None
         add_meta("Duration", duration, "bold")
 
-        yield Container(
+        main_content = Vertical(
             Static(meta_text, id="detail-meta"),
             RichLog(id="detail-events", wrap=False),
         )
+        yield main_content
+        yield Container(Toast(), id="toast-container")
         yield Footer()
 
     def on_mount(self) -> None:
         """Populate and focus the log."""
+        self._ensure_toast_bus()
         log = self.query_one("#detail-events", RichLog)
         log.can_focus = True
         log.write(Text("Events", style="bold"))
@@ -149,6 +180,61 @@ class RunDetailScreen(ModalScreen[None]):
     def _log(self) -> RichLog:
         return self.query_one("#detail-events", RichLog)
 
+    def action_copy_run_id(self) -> None:
+        """Copy the run id to the clipboard."""
+        run_id = getattr(self.detail, "id", None)
+        if not run_id:
+            self._announce_status("Run ID unavailable.")
+            return
+        self._copy_to_clipboard(str(run_id), label="Run ID")
+
+    def action_copy_detail_json(self) -> None:
+        """Copy the run detail JSON to the clipboard."""
+        payload = self._detail_json_payload()
+        if payload is None:
+            return
+        self._copy_to_clipboard(payload, label="Run JSON")
+
+    def _detail_json_payload(self) -> str | None:
+        detail = self.detail
+        if detail is None:
+            self._announce_status("Run detail unavailable.")
+            return None
+        if isinstance(detail, str):
+            return detail
+        if isinstance(detail, dict):
+            payload = detail
+        elif hasattr(detail, "model_dump"):
+            payload = detail.model_dump(mode="json")
+        elif hasattr(detail, "dict"):
+            payload = detail.dict()
+        else:
+            payload = getattr(detail, "__dict__", {"value": detail})
+        try:
+            return json.dumps(payload, indent=2, ensure_ascii=False, default=str)
+        except Exception as exc:
+            self._announce_status(f"Failed to serialize run detail: {exc}")
+            return None
+
+    def _append_copy_fallback(self, text: str) -> None:
+        try:
+            log = self._log()
+        except Exception:
+            self._announce_status(text)
+            return
+        log.write(Text(text))
+        log.write(Text(""))
+
+    def _ensure_toast_bus(self) -> None:
+        """Ensure toast bus is initialized and connected to message handler."""
+        if self._local_toasts is not None:
+            return  # pragma: no cover - early return when already initialized
+
+        def _notify(m: ToastBus.Changed) -> None:
+            self.post_message(m)
+
+        self._local_toasts = ToastBus(on_change=_notify)
+
     @staticmethod
     def _status_style(status: str | None) -> str:
         """Return a Rich style name for the status pill."""
@@ -220,11 +306,18 @@ class RunDetailScreen(ModalScreen[None]):
             update_status(message, append=True)
 
 
-class RemoteRunsTextualApp(App[None]):
+class RemoteRunsTextualApp(ToastHandlerMixin, App[None]):
     """Textual application for browsing remote runs."""
 
     CSS = f"""
-    Screen {{ layout: vertical; }}
+    Screen {{ layout: vertical; layers: base toasts; }}
+    #toast-container {{
+        width: 100%;
+        height: auto;
+        dock: top;
+        align: right top;
+        layer: toasts;
+    }}
     #status-bar {{ height: 3; padding: 0 1; }}
     #agent-context {{ min-width: 25; padding-right: 1; }}
     #{RUNS_LOADING_ID} {{ width: 8; }}
@@ -247,6 +340,7 @@ class RemoteRunsTextualApp(App[None]):
         *,
         agent_name: str | None = None,
         agent_id: str | None = None,
+        ctx: TUIContext | None = None,
     ):
         """Initialize the remote runs Textual application.
 
@@ -256,6 +350,7 @@ class RemoteRunsTextualApp(App[None]):
             callbacks: Callback bundle for data operations.
             agent_name: Optional agent name for display purposes.
             agent_id: Optional agent ID for display purposes.
+            ctx: Shared TUI context.
         """
         super().__init__()
         self.current_page = initial_page
@@ -265,6 +360,7 @@ class RemoteRunsTextualApp(App[None]):
         self.current_rows = initial_page.data[:]
         self.agent_name = (agent_name or "").strip()
         self.agent_id = (agent_id or "").strip()
+        self._ctx = ctx
         self._active_export_tasks: set[asyncio.Task[None]] = set()
         self._page_loader_task: asyncio.Task[Any] | None = None
         self._detail_loader_task: asyncio.Task[Any] | None = None
@@ -273,9 +369,10 @@ class RemoteRunsTextualApp(App[None]):
     def compose(self) -> ComposeResult:
         """Build layout."""
         yield Header()
-        table = DataTable(id=RUNS_TABLE_ID)
-        table.cursor_type = "row"
-        table.add_columns(
+        yield Container(Toast(), id="toast-container")
+        table = DataTable(id=RUNS_TABLE_ID)  # pragma: no cover - mocked in tests
+        table.cursor_type = "row"  # pragma: no cover - mocked in tests
+        table.add_columns(  # pragma: no cover - mocked in tests
             "Run UUID",
             "Type",
             "Status",
@@ -292,8 +389,18 @@ class RemoteRunsTextualApp(App[None]):
         )
         yield Footer()  # pragma: no cover - interactive UI, tested via integration
 
+    def _ensure_toast_bus(self) -> None:
+        if self._ctx is None or self._ctx.toasts is not None:
+            return
+
+        def _notify(m: ToastBus.Changed) -> None:
+            self.post_message(m)
+
+        self._ctx.toasts = ToastBus(on_change=_notify)
+
     def on_mount(self) -> None:
         """Render the initial page."""
+        self._ensure_toast_bus()
         self._hide_loading()
         self._render_page(self.current_page)
 
@@ -315,7 +422,7 @@ class RemoteRunsTextualApp(App[None]):
         if self.current_rows:
             self.cursor_index = max(0, min(self.cursor_index, len(self.current_rows) - 1))
             table.focus()
-            table.cursor_coordinate = (self.cursor_index, 0)
+            table.cursor_coordinate = Coordinate(self.cursor_index, 0)
         self.current_page = runs_page
         total_pages = max(1, (runs_page.total + runs_page.limit - 1) // runs_page.limit)
         agent_display = self.agent_name or "Runs"
@@ -554,8 +661,8 @@ class RemoteRunsTextualApp(App[None]):
         if detail is None:
             self._update_status("Failed to load run detail.", append=True)
             return
-        self.push_screen(RunDetailScreen(detail, on_export=self.queue_export_from_detail))
-        self._update_status("Detail view: ↑/↓ scroll · PgUp/PgDn · q/Esc close · e export")
+        self.push_screen(RunDetailScreen(detail, on_export=self.queue_export_from_detail, ctx=self._ctx))
+        self._update_status("Detail view: ↑/↓ scroll · PgUp/PgDn · q/Esc close · c copy ID · C copy JSON · e export")
 
     def queue_export_from_detail(self, detail: Any) -> None:
         """Start an export from the detail modal."""

glaip_sdk/cli/slash/tui/toast.py

@@ -1,18 +1,20 @@
-"""Toast notification helpers for Textual TUIs.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
+"""Toast widgets and state management for the TUI."""
 
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum
+from typing import Any, cast
+
+from rich.text import Text
+from textual.message import Message
+from textual.widgets import Static
 
 
 class ToastVariant(str, Enum):
-    """Toast message variant."""
+    """Toast message variant for styling and behavior."""
 
     INFO = "info"
     SUCCESS = "success"
@@ -30,7 +32,7 @@ DEFAULT_TOAST_DURATIONS_SECONDS: dict[ToastVariant, float] = {
 
 @dataclass(frozen=True, slots=True)
 class ToastState:
-    """Immutable toast payload."""
+    """Immutable toast notification state."""
 
     message: str
     variant: ToastVariant
@@ -38,16 +40,25 @@ class ToastState:
 
 
 class ToastBus:
-    """Single-toast state holder with auto-dismiss."""
+    """Toast state manager with auto-dismiss functionality."""
 
-    def __init__(self) -> None:
-        """Initialize the bus."""
+    class Changed(Message):
+        """Message sent when toast state changes."""
+
+        def __init__(self, state: ToastState | None) -> None:
+            """Initialize the changed message with new toast state."""
+            super().__init__()
+            self.state = state
+
+    def __init__(self, on_change: Callable[[ToastBus.Changed], None] | None = None) -> None:
+        """Initialize the toast bus with optional change callback."""
         self._state: ToastState | None = None
         self._dismiss_task: asyncio.Task[None] | None = None
+        self._on_change = on_change
 
     @property
     def state(self) -> ToastState | None:
-        """Return the current toast state."""
+        """Return the current toast state, or None if no toast is shown."""
         return self._state
 
     def show(
@@ -57,7 +68,14 @@ class ToastBus:
         *,
         duration_seconds: float | None = None,
     ) -> None:
-        """Set toast state and schedule auto-dismiss."""
+        """Show a toast notification with the given message and variant.
+
+        Args:
+            message: The message to display in the toast.
+            variant: The visual variant of the toast (INFO, SUCCESS, WARNING, ERROR).
+            duration_seconds: Optional custom duration in seconds. If None, uses default
+                duration for the variant (2s for SUCCESS, 3s for INFO/WARNING, 5s for ERROR).
+        """
         resolved_variant = self._coerce_variant(variant)
         resolved_duration = (
             DEFAULT_TOAST_DURATIONS_SECONDS[resolved_variant] if duration_seconds is None else float(duration_seconds)
@@ -80,23 +98,26 @@ class ToastBus:
             ) from None
 
         self._dismiss_task = loop.create_task(self._auto_dismiss(resolved_duration))
+        self._notify_changed()
 
     def clear(self) -> None:
-        """Clear the current toast."""
+        """Clear the current toast notification immediately."""
         self._cancel_dismiss_task()
         self._state = None
+        self._notify_changed()
 
     def copy_success(self, label: str | None = None) -> None:
-        """Show clipboard success toast."""
+        """Show a success toast for clipboard copy operations.
+
+        Args:
+            label: Optional label for what was copied (e.g., "Run ID", "JSON").
+        """
         message = "Copied to clipboard" if not label else f"Copied {label} to clipboard"
         self.show(message=message, variant=ToastVariant.SUCCESS)
 
     def copy_failed(self) -> None:
-        """Show clipboard failure toast."""
-        self.show(
-            message="Clipboard unavailable. Text printed below",
-            variant=ToastVariant.WARNING,
-        )
+        """Show a warning toast when clipboard copy fails."""
+        self.show(message="Clipboard unavailable. Text printed below.", variant=ToastVariant.WARNING)
 
     def _coerce_variant(self, variant: ToastVariant | str) -> ToastVariant:
         if isinstance(variant, ToastVariant):
@@ -121,3 +142,233 @@ class ToastBus:
 
         self._state = None
         self._dismiss_task = None
+        self._notify_changed()
+
+    def _notify_changed(self) -> None:
+        if self._on_change:
+            self._on_change(ToastBus.Changed(self._state))
+
+
+class ToastHandlerMixin:
+    """Mixin providing common toast handling functionality.
+
+    Classes that inherit from this mixin can handle ToastBus.Changed messages
+    by automatically updating all Toast widgets in the component tree.
+    """
+
+    def on_toast_bus_changed(self, message: ToastBus.Changed) -> None:
+        """Refresh the toast widget when the toast bus updates.
+
+        Args:
+            message: The toast bus changed message containing the new state.
+        """
+        try:
+            for toast in self.query(Toast):
+                toast.update_state(message.state)
+        except Exception:
+            pass
+
+
+class ClipboardToastMixin:
+    """Mixin providing clipboard and toast orchestration functionality.
+
+    Classes that inherit from this mixin get shared clipboard adapter selection,
+    OSC52 writer setup, toast bus lookup, and copy-success/failure orchestration.
+    This consolidates duplicate clipboard/toast logic across TUI apps.
+
+    Expected attributes:
+        _ctx: TUIContext | None - Shared TUI context (optional)
+        _clipboard: ClipboardAdapter | None - Cached clipboard adapter (optional)
+        _local_toasts: ToastBus | None - Local toast bus instance (optional)
+    """
+
+    def _clipboard_adapter(self) -> Any:  # ClipboardAdapter
+        """Get or create a clipboard adapter instance.
+
+        Returns:
+            ClipboardAdapter instance, preferring context's adapter if available.
+        """
+        # Import here to avoid circular dependency
+        from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter  # noqa: PLC0415
+
+        ctx = getattr(self, "_ctx", None)
+        clipboard = getattr(self, "_clipboard", None)
+
+        if ctx is not None and ctx.clipboard is not None:
+            return cast(ClipboardAdapter, ctx.clipboard)
+        if clipboard is not None:
+            return clipboard
+
+        adapter = ClipboardAdapter(terminal=ctx.terminal if ctx else None)
+        if ctx is not None:
+            ctx.clipboard = adapter
+        else:
+            self._clipboard = adapter
+        return adapter
+
+    def _osc52_writer(self) -> Callable[[str], Any] | None:
+        """Get an OSC52 writer function if console output is available.
+
+        Returns:
+            Writer function that writes OSC52 sequences to console output, or None.
+        """
+        try:
+            # Try self.app.console first (for Screen subclasses)
+            if hasattr(self, "app") and hasattr(self.app, "console"):
+                console = self.app.console
+            # Fall back to self.console (for App subclasses)
+            else:
+                console = getattr(self, "console", None)
+        except Exception:
+            return None
+
+        if console is None:
+            return None
+
+        output = getattr(console, "file", None)
+        if output is None:
+            return None
+
+        def _write(sequence: str, _output: Any = output) -> None:
+            _output.write(sequence)
+            _output.flush()
+
+        return _write
+
+    def _toast_bus(self) -> ToastBus | None:
+        """Get the toast bus instance.
+
+        Returns:
+            ToastBus instance, preferring context's bus if available, or None.
+        """
+        local_toasts = getattr(self, "_local_toasts", None)
+        ctx = getattr(self, "_ctx", None)
+
+        if local_toasts is not None:
+            return local_toasts
+        if ctx is not None and ctx.toasts is not None:
+            return ctx.toasts
+        return None
+
+    def _copy_to_clipboard(self, text: str, *, label: str | None = None) -> None:
+        """Copy text to clipboard and show toast notification.
+
+        Args:
+            text: The text to copy to clipboard.
+            label: Optional label for what was copied (e.g., "Run ID", "JSON").
+        """
+        adapter = self._clipboard_adapter()
+        writer = self._osc52_writer()
+        if writer:
+            result = adapter.copy(text, writer=writer)
+        else:
+            result = adapter.copy(text)
+
+        toasts = self._toast_bus()
+        if result.success:
+            if toasts:
+                toasts.copy_success(label)
+            else:
+                # Fallback to status announcement if toast bus unavailable
+                if hasattr(self, "_announce_status"):
+                    if label:
+                        self._announce_status(f"Copied {label} to clipboard.")
+                    else:
+                        self._announce_status("Copied to clipboard.")
+            return
+
+        # Copy failed
+        if toasts:
+            toasts.copy_failed()
+        else:
+            # Fallback to status announcement if toast bus unavailable
+            if hasattr(self, "_announce_status"):
+                self._announce_status("Clipboard unavailable. Text printed below.")
+
+        # Append fallback text output
+        if hasattr(self, "_append_copy_fallback"):
+            self._append_copy_fallback(text)
+
+
+class Toast(Static):
+    """A Textual widget that displays toast notifications at the top-right of the screen.
+
+    The Toast widget is updated via `update_state()` calls from message handlers
+    (e.g., `on_toast_bus_changed`). The widget does not auto-subscribe to ToastBus
+    state changes; the app must call `update_state()` when toast state changes.
+    """
+
+    DEFAULT_CSS = """
+    #toast-container {
+        width: 100%;
+        height: auto;
+        dock: top;
+        align: right top;
+    }
+
+    Toast {
+        width: auto;
+        min-width: 20;
+        max-width: 40;
+        height: auto;
+        padding: 0 1;
+        margin: 1 2;
+        background: $surface;
+        color: $text;
+        border: solid $primary;
+        display: none;
+    }
+
+    Toast.visible {
+        display: block;
+    }
+
+    Toast.info {
+        border: solid $accent;
+    }
+
+    Toast.success {
+        border: solid $success;
+    }
+
+    Toast.warning {
+        border: solid $warning;
+    }
+
+    Toast.error {
+        border: solid $error;
+    }
+    """
+
+    def __init__(self) -> None:
+        """Initialize the Toast widget.
+
+        The widget is updated via `update_state()` calls from message handlers
+        (e.g., `on_toast_bus_changed`). The widget does not auto-subscribe to
+        a ToastBus; the app must call `update_state()` when toast state changes.
+        """
+        super().__init__("")
+
+    def update_state(self, state: ToastState | None) -> None:
+        """Update the toast display based on the provided state.
+
+        Args:
+            state: The toast state to display, or None to hide the toast.
+        """
+        if not state:
+            self.remove_class("visible")
+            return
+
+        icon = "ℹ️"
+        if state.variant == ToastVariant.SUCCESS:
+            icon = "✅"
+        elif state.variant == ToastVariant.WARNING:
+            icon = "⚠️"
+        elif state.variant == ToastVariant.ERROR:
+            icon = "❌"
+
+        self.update(Text.assemble((f"{icon} ", "bold"), state.message))
+
+        self.remove_class("info", "success", "warning", "error")
+        self.add_class(state.variant.value)
+        self.add_class("visible")