glaip-sdk 0.7.7__py3-none-any.whl → 0.7.12__py3-none-any.whl

glaip_sdk/cli/slash/tui/clipboard.py

@@ -45,6 +45,36 @@ _SUBPROCESS_COMMANDS: dict[ClipboardMethod, list[str]] = {
     ClipboardMethod.CLIP: ["clip"],
 }
 
+_ENV_CLIPBOARD_METHOD = "AIP_TUI_CLIPBOARD_METHOD"
+_ENV_CLIPBOARD_FORCE = "AIP_TUI_CLIPBOARD_FORCE"
+_ENV_METHOD_MAP = {
+    "osc52": ClipboardMethod.OSC52,
+    "pbcopy": ClipboardMethod.PBCOPY,
+    "xclip": ClipboardMethod.XCLIP,
+    "xsel": ClipboardMethod.XSEL,
+    "wl-copy": ClipboardMethod.WL_COPY,
+    "wl_copy": ClipboardMethod.WL_COPY,
+    "clip": ClipboardMethod.CLIP,
+    "none": ClipboardMethod.NONE,
+}
+
+
+def _resolve_env_method() -> ClipboardMethod | None:
+    raw = os.getenv(_ENV_CLIPBOARD_METHOD)
+    if not raw:
+        return None
+    value = raw.strip().lower()
+    if value in ("auto", "default"):
+        return None
+    return _ENV_METHOD_MAP.get(value)
+
+
+def _is_env_force_enabled() -> bool:
+    raw = os.getenv(_ENV_CLIPBOARD_FORCE)
+    if not raw:
+        return False
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
 
 class ClipboardAdapter:
     """Cross-platform clipboard access with OSC 52 fallback."""
@@ -57,7 +87,16 @@ class ClipboardAdapter:
     ) -> None:
         """Initialize the adapter."""
         self._terminal = terminal
-        self._method = method or self._detect_method()
+        self._force_method = False
+        if method is not None:
+            self._method = method
+        else:
+            env_method = _resolve_env_method()
+            if env_method is not None:
+                self._method = env_method
+                self._force_method = _is_env_force_enabled()
+            else:
+                self._method = self._detect_method()
 
     @property
     def method(self) -> ClipboardMethod:
@@ -77,25 +116,34 @@ class ClipboardAdapter:
 
         command = _SUBPROCESS_COMMANDS.get(self._method)
         if command is None:
+            if self._force_method:
+                return ClipboardResult(False, self._method, "Forced clipboard method unavailable.")
             return self._copy_osc52(text, writer=writer)
 
         result = self._copy_subprocess(command, text)
         if not result.success:
+            if self._force_method:
+                return result
             return self._copy_osc52(text, writer=writer)
 
         return result
 
     def _detect_method(self) -> ClipboardMethod:
+        system = platform.system()
+        method = ClipboardMethod.NONE
+        if system == "Darwin":
+            method = self._detect_darwin_method()
+        elif system == "Linux":
+            method = self._detect_linux_method()
+        elif system == "Windows":
+            method = self._detect_windows_method()
+
+        if method is not ClipboardMethod.NONE:
+            return method
+
         if self._terminal.osc52 if self._terminal else detect_osc52_support():
             return ClipboardMethod.OSC52
 
-        system = platform.system()
-        if system == "Darwin":
-            return self._detect_darwin_method()
-        if system == "Linux":
-            return self._detect_linux_method()
-        if system == "Windows":
-            return self._detect_windows_method()
         return ClipboardMethod.NONE
 
     def _detect_darwin_method(self) -> ClipboardMethod:

glaip_sdk/cli/slash/tui/context.py

@@ -12,13 +12,14 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
 
+from glaip_sdk.cli.account_store import get_account_store
+from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter
+from glaip_sdk.cli.slash.tui.keybind_registry import KeybindRegistry
 from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities
 from glaip_sdk.cli.slash.tui.theme import ThemeManager
-
-if TYPE_CHECKING:
-    from glaip_sdk.cli.slash.tui.toast import ToastBus
+from glaip_sdk.cli.slash.tui.toast import ToastBus
+from glaip_sdk.cli.tui_settings import load_tui_settings
 
 
 @dataclass
@@ -37,23 +38,50 @@ class TUIContext:
     """
 
     terminal: TerminalCapabilities
-    keybinds: object | None = None
+    keybinds: KeybindRegistry | None = None
     theme: ThemeManager | None = None
     toasts: ToastBus | None = None
-    clipboard: object | None = None
+    clipboard: ClipboardAdapter | None = None
 
     @classmethod
-    async def create(cls) -> TUIContext:
+    async def create(cls, *, detect_osc11: bool = True) -> TUIContext:
         """Create a TUIContext instance with detected terminal capabilities.
 
         This factory method detects terminal capabilities asynchronously and
-        returns a populated TUIContext instance. Other components (keybinds,
-        theme, toasts, clipboard) will be set incrementally as they are created.
+        returns a populated TUIContext instance with all services initialized
+        (keybinds, theme, toasts, clipboard).
+
+        Args:
+            detect_osc11: When False, skip OSC 11 background detection.
 
         Returns:
-            TUIContext instance with terminal capabilities detected.
+            TUIContext instance with all services initialized.
         """
-        terminal = await TerminalCapabilities.detect()
-        theme_name = os.getenv("AIP_TUI_THEME") or None
-        theme = ThemeManager(terminal, theme=theme_name)
-        return cls(terminal=terminal, theme=theme)
+        terminal = await TerminalCapabilities.detect(detect_osc11=detect_osc11)
+        store = get_account_store()
+        settings = load_tui_settings(store=store)
+
+        # Handle env var override: normalize empty strings and "default" to None
+        # Empty string from os.getenv() is falsy, so strip() result becomes None in the or expression
+        env_theme = os.getenv("AIP_TUI_THEME")
+        env_theme = env_theme.strip() if env_theme else None
+        if env_theme and env_theme.lower() == "default":
+            env_theme = None
+
+        theme_name = env_theme or settings.theme_name
+        theme = ThemeManager(
+            terminal,
+            mode=settings.theme_mode,
+            theme=theme_name,
+            settings_store=store,
+        )
+        keybinds = KeybindRegistry()
+        toasts = ToastBus()
+        clipboard = ClipboardAdapter(terminal=terminal)
+        return cls(
+            terminal=terminal,
+            keybinds=keybinds,
+            theme=theme,
+            toasts=toasts,
+            clipboard=clipboard,
+        )

glaip_sdk/cli/slash/tui/layouts/__init__.py

@@ -0,0 +1,14 @@
+"""Layout components for TUI applications.
+
+This package provides reusable layout components following the Harlequin pattern
+for multi-pane data-rich screens.
+"""
+
+from __future__ import annotations
+
+try:  # pragma: no cover - optional dependency
+    from glaip_sdk.cli.slash.tui.layouts.harlequin import HarlequinScreen
+except Exception:  # pragma: no cover - optional dependency
+    HarlequinScreen = None  # type: ignore[assignment, misc]
+
+__all__ = ["HarlequinScreen"]

glaip_sdk/cli/slash/tui/layouts/harlequin.py

@@ -0,0 +1,160 @@
+"""Harlequin layout base class for multi-pane TUI screens.
+
+This module provides the HarlequinScreen base class, which implements a modern
+multi-pane "Harlequin" layout pattern for data-rich TUI screens. The layout uses
+a 25/75 split with a list on the left and detail content on the right.
+
+The Harlequin pattern is inspired by the Harlequin SQL client and provides:
+- Left Pane (25%): ListView or compact table for item selection
+- Right Pane (75%): Detail dashboard showing all fields, status, and action buttons
+- Black background (#000000) that overrides terminal transparency
+- Primary Blue borders (#005CB8)
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+try:  # pragma: no cover - optional dependency
+    from textual.containers import Container, Horizontal, Vertical
+    from textual.screen import Screen
+except Exception:  # pragma: no cover - optional dependency
+
+    class Screen:  # type: ignore[no-redef]
+        """Fallback Screen stub when Textual is unavailable."""
+
+        def __class_getitem__(cls, _):
+            """Return the class for typing subscripts."""
+            return cls
+
+    Horizontal = None  # type: ignore[assignment]
+    Vertical = None  # type: ignore[assignment]
+    Container = None  # type: ignore[assignment]
+
+if TYPE_CHECKING:
+    from glaip_sdk.cli.slash.tui.context import TUIContext
+
+try:  # pragma: no cover - optional dependency
+    from glaip_sdk.cli.slash.tui.toast import Toast
+except Exception:  # pragma: no cover - optional dependency
+    Toast = None  # type: ignore[assignment, misc]
+
+# GDP Labs Brand Palette
+PRIMARY_BLUE = "#005CB8"
+BLACK_BACKGROUND = "#000000"
+
+
+class HarlequinScreen(Screen[None]):  # type: ignore[misc]
+    """Base class for Harlequin-style multi-pane screens.
+
+    This screen provides a 25/75 split layout with a left pane for navigation
+    and a right pane for details. The layout uses a black background that
+    overrides terminal transparency and primary blue borders.
+
+    Subclasses should override `compose()` to add their specific widgets to
+    the left and right panes. Use the container IDs "left-pane" and "right-pane"
+    to target specific panes in CSS or when querying widgets.
+
+    Example:
+        ```python
+        class AccountHarlequinScreen(HarlequinScreen):
+            def compose(self) -> ComposeResult:
+                yield from super().compose()
+                # Add widgets to left and right panes
+                self.query_one("#left-pane").mount(AccountListView())
+                self.query_one("#right-pane").mount(AccountDetailView())
+        ```
+
+    CSS:
+        The screen includes default styling for the Harlequin layout:
+        - Black background (#000000) for the entire screen
+        - Primary blue borders (#005CB8) for panes
+        - 25% width for left pane, 75% width for right pane
+    """
+
+    CSS = """
+    HarlequinScreen {
+        background: #000000;
+        layers: base toasts;
+    }
+
+    #harlequin-container {
+        width: 100%;
+        height: 100%;
+    }
+
+    #left-pane {
+        width: 25%;
+        border: solid #005CB8;
+        background: #000000;
+    }
+
+    #right-pane {
+        width: 75%;
+        border: solid #005CB8;
+        background: #000000;
+    }
+
+    #toast-container {
+        width: 100%;
+        height: auto;
+        dock: top;
+        align: right top;
+        layer: toasts;
+    }
+    """
+
+    def __init__(
+        self,
+        *,
+        ctx: TUIContext | None = None,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        """Initialize the Harlequin screen.
+
+        Args:
+            ctx: Optional TUI context for accessing services (keybinds, theme, toasts, clipboard).
+            name: Optional name for the screen.
+            id: Optional ID for the screen.
+            classes: Optional CSS classes for the screen.
+        """
+        super().__init__(name=name, id=id, classes=classes)
+        self._ctx: TUIContext | None = ctx
+
+    def compose(self) -> Any:
+        """Compose the Harlequin layout with left and right panes.
+
+        This method creates the base 25/75 split layout. Subclasses should
+        call `super().compose()` and then add their specific widgets to the
+        left and right panes.
+
+        Returns:
+            ComposeResult yielding the base layout containers.
+        """
+        if Horizontal is None or Vertical is None or Container is None:
+            return
+
+        # Main container with horizontal split (25/75)
+        yield Horizontal(
+            Vertical(id="left-pane"),
+            Vertical(id="right-pane"),
+            id="harlequin-container",
+        )
+
+        # Toast container for notifications
+        if Toast is not None and Container is not None:
+            yield Container(Toast(), id="toast-container")
+
+    @property
+    def ctx(self) -> TUIContext | None:
+        """Get the TUI context if available.
+
+        Returns:
+            TUIContext instance or None if not provided.
+        """
+        return self._ctx

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/terminal.py

@@ -71,7 +71,7 @@ class TerminalCapabilities:
         return "light" if luminance > 0.5 else "dark"
 
     @classmethod
-    async def detect(cls) -> TerminalCapabilities:
+    async def detect(cls, *, detect_osc11: bool = True) -> TerminalCapabilities:
         """Detect terminal capabilities asynchronously with fast timeout.
 
         This method performs capability detection including OSC 11 background
@@ -80,6 +80,9 @@ class TerminalCapabilities:
         if the terminal doesn't respond within the timeout; use
         detect_terminal_background() for full 1-second timeout when needed.
 
+        Args:
+            detect_osc11: When False, skip OSC 11 background detection.
+
         Returns:
             TerminalCapabilities instance with detected capabilities.
         """
@@ -93,8 +96,10 @@ class TerminalCapabilities:
         mouse = tty_available and term not in ("dumb", "")
         truecolor = colorterm in ("truecolor", "24bit")
 
-        # OSC 11 detection: use fast path (<100ms timeout)
-        osc11_bg: str | None = await _detect_osc11_fast()
+        osc11_bg: str | None = None
+        if detect_osc11 and tty_available and sys.stdin.isatty():
+            # OSC 11 detection: use fast path (<100ms timeout)
+            osc11_bg = await _detect_osc11_fast()
 
         return cls(
             tty=tty_available,