glaip-sdk 0.6.5b6__py3-none-any.whl → 0.7.7__py3-none-any.whl

glaip_sdk/cli/slash/accounts_controller.py

@@ -151,79 +151,149 @@ class AccountsController:
 
     def _render_textual(self, rows: list[dict[str, str | bool]], store: AccountStore, env_lock: bool) -> None:
         """Launch the Textual accounts browser."""
-        callbacks = AccountsTUICallbacks(switch_account=lambda name: self._switch_account(store, name, env_lock))
+        active_before = store.get_active_account()
+        notified = False
+
+        def _switch_in_textual(name: str) -> tuple[bool, str]:
+            nonlocal notified
+            switched, message = self._switch_account(
+                store,
+                name,
+                env_lock,
+                emit_console=False,
+                invalidate_session=True,
+            )
+            if switched:
+                notified = True
+            return switched, message
+
+        callbacks = AccountsTUICallbacks(switch_account=_switch_in_textual)
         active = next((row["name"] for row in rows if row.get("active")), None)
-        run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks)
-        # Exit snapshot: surface a success banner when a switch occurred inside the TUI
-        active_after = store.get_active_account() or "default"
+        try:
+            # Inject TUI context for theme support
+            tui_ctx = getattr(self.session, "tui_ctx", None)
+            run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks, ctx=tui_ctx)
+        except Exception as exc:  # pragma: no cover - defensive around Textual failures
+            self.console.print(f"[{WARNING_STYLE}]Accounts browser exited unexpectedly: {exc}[/]")
+
+        # Exit snapshot: surface a success banner when a switch occurred inside the TUI.
+        # Always notify when the active account changed, even if Textual raised.
+        active_after = store.get_active_account()
+        if active_after != active_before and not notified:
+            self._notify_account_switched(active_after)
         if active_after != active:
             host_after = ""
-            account_after = store.get_account(active_after) if hasattr(store, "get_account") else None
+            display_account = active_after or "default"
+            account_after = store.get_account(display_account) if hasattr(store, "get_account") else None
             if account_after:
                 host_after = account_after.get("api_url", "")
             host_suffix = f" • {host_after}" if host_after else ""
             self.console.print(
                 AIPPanel(
-                    f"[{SUCCESS_STYLE}]Active account ➜ {active_after}[/]{host_suffix}",
+                    f"[{SUCCESS_STYLE}]Active account ➜ {display_account}[/]{host_suffix}",
                     title="✅ Account Switched",
                     border_style=SUCCESS_STYLE,
                 )
             )
 
-    def _switch_account(self, store: AccountStore, name: str, env_lock: bool) -> tuple[bool, str]:
-        """Validate and switch active account; returns (success, message)."""
+    def _format_connection_error_message(self, error_reason: str, account_name: str, api_url: str) -> str:
+        """Format error message for connection validation failures."""
+        code, detail = self._parse_error_reason(error_reason)
+        if code == "connection_failed":
+            return f"Switch aborted: cannot reach {api_url}. Check URL or network."
+        if code == "api_failed":
+            return f"Switch aborted: API error for '{account_name}'. Check credentials."
+        detail_suffix = f": {detail}" if detail else ""
+        return f"Switch aborted: {code or 'Validation failed'}{detail_suffix}"
+
+    def _emit_error_message(self, msg: str, style: str = ERROR_STYLE) -> None:
+        """Emit an error or warning message to the console."""
+        self.console.print(f"[{style}]{msg}[/]")
+
+    def _validate_account_switch(
+        self, store: AccountStore, name: str, env_lock: bool, emit_console: bool
+    ) -> tuple[bool, str, dict[str, str] | None]:
+        """Validate account switch prerequisites; returns (is_valid, error_msg, account_dict)."""
         if env_lock:
             msg = "Env credentials detected (AIP_API_URL/AIP_API_KEY); switching is disabled."
-            self.console.print(f"[{WARNING_STYLE}]{msg}[/]")
-            return False, msg
+            if emit_console:
+                self._emit_error_message(msg, WARNING_STYLE)
+            return False, msg, None
 
         account = store.get_account(name)
         if not account:
             msg = f"Account '{name}' not found."
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
-            return False, msg
+            if emit_console:
+                self._emit_error_message(msg)
+            return False, msg, None
 
         api_url = account.get("api_url", "")
         api_key = account.get("api_key", "")
         if not api_url or not api_key:
             edit_cmd = f"aip accounts edit {name}"
             msg = f"Account '{name}' is missing credentials. Use `/login` or `{edit_cmd}`."
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
-            return False, msg
+            if emit_console:
+                self._emit_error_message(msg)
+            return False, msg, None
 
         ok, error_reason = check_connection_with_reason(api_url, api_key, abort_on_error=False)
         if not ok:
-            code, detail = self._parse_error_reason(error_reason)
-            if code == "connection_failed":
-                msg = f"Switch aborted: cannot reach {api_url}. Check URL or network."
-            elif code == "api_failed":
-                msg = f"Switch aborted: API error for '{name}'. Check credentials."
-            else:
-                detail_suffix = f": {detail}" if detail else ""
-                msg = f"Switch aborted: {code or 'Validation failed'}{detail_suffix}"
-            self.console.print(f"[{WARNING_STYLE}]{msg}[/]")
-            return False, msg
+            msg = self._format_connection_error_message(error_reason, name, api_url)
+            if emit_console:
+                self._emit_error_message(msg, WARNING_STYLE)
+            return False, msg, None
 
+        return True, "", account
+
+    def _execute_account_switch(
+        self, store: AccountStore, name: str, account: dict[str, str], invalidate_session: bool, emit_console: bool
+    ) -> tuple[bool, str]:
+        """Execute the account switch and emit success message."""
         try:
             store.set_active_account(name)
+            api_url = account.get("api_url", "")
+            api_key = account.get("api_key", "")
             masked_key = mask_api_key_display(api_key)
-            self.console.print(
-                AIPPanel(
-                    f"[{SUCCESS_STYLE}]Active account ➜ {name}[/]\nAPI URL: {api_url}\nKey: {masked_key}",
-                    title="✅ Account Switched",
-                    border_style=SUCCESS_STYLE,
+            if invalidate_session:
+                self._notify_account_switched(name)
+            if emit_console:
+                self.console.print(
+                    AIPPanel(
+                        f"[{SUCCESS_STYLE}]Active account ➜ {name}[/]\nAPI URL: {api_url}\nKey: {masked_key}",
+                        title="✅ Account Switched",
+                        border_style=SUCCESS_STYLE,
+                    )
                 )
-            )
             return True, f"Switched to '{name}'."
         except AccountStoreError as exc:
             msg = f"Failed to set active account: {exc}"
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            if emit_console:
+                self._emit_error_message(msg)
             return False, msg
         except Exception as exc:  # NOSONAR(S1045) - catch-all needed for unexpected errors
             msg = f"Unexpected error while switching to '{name}': {exc}"
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            if emit_console:
+                self._emit_error_message(msg)
             return False, msg
 
+    def _switch_account(
+        self,
+        store: AccountStore,
+        name: str,
+        env_lock: bool,
+        *,
+        emit_console: bool = True,
+        invalidate_session: bool = True,
+    ) -> tuple[bool, str]:
+        """Validate and switch active account; returns (success, message)."""
+        is_valid, error_msg, account = self._validate_account_switch(store, name, env_lock, emit_console)
+        if not is_valid:
+            return False, error_msg
+
+        if account is None:  # Defensive – should never happen, but avoid crashing in production
+            return False, "Unable to locate account after validation."
+        return self._execute_account_switch(store, name, account, invalidate_session, emit_console)
+
     @staticmethod
     def _parse_error_reason(reason: str | None) -> tuple[str, str]:
         """Parse error reason into (code, detail) to avoid fragile substring checks."""
@@ -404,8 +474,18 @@ class AccountsController:
             except Exception as exc:
                 self.console.print(f"[{WARNING_STYLE}]Account saved but could not set active: {exc}[/]")
             else:
+                self._notify_account_switched(name)
                 self._announce_active_change(store, name)
 
+    def _notify_account_switched(self, name: str | None) -> None:
+        """Best-effort notify the hosting session that the active account changed."""
+        notify = getattr(self.session, "on_account_switched", None)
+        if callable(notify):
+            try:
+                notify(name)
+            except Exception:  # pragma: no cover - best-effort callback
+                pass
+
     def _confirm_delete_prompt(self, name: str) -> bool:
         """Ask for delete confirmation; return True when confirmed."""
         self.console.print(f"[{WARNING_STYLE}]Type '{name}' to confirm deletion. This cannot be undone.[/]")

glaip_sdk/cli/slash/agent_session.py

@@ -17,7 +17,7 @@ from glaip_sdk.cli.commands.agents import run as agents_run_command
 from glaip_sdk.cli.constants import DEFAULT_AGENT_INSTRUCTION_PREVIEW_LIMIT
 from glaip_sdk.cli.hints import format_command_hint
 from glaip_sdk.cli.slash.prompt import _HAS_PROMPT_TOOLKIT, FormattedText
-from glaip_sdk.cli.utils import bind_slash_session_context
+from glaip_sdk.cli.core.context import bind_slash_session_context
 
 if TYPE_CHECKING:  # pragma: no cover - type checking only
     from glaip_sdk.cli.slash.session import SlashSession
@@ -38,7 +38,10 @@ class AgentRunSession:
         self.console = session.console
         self._agent_id = str(getattr(agent, "id", ""))
         self._agent_name = getattr(agent, "name", "") or self._agent_id
-        self._prompt_placeholder: str = "Chat with this agent here; use / for shortcuts. Alt+Enter inserts a newline."
+        self._prompt_placeholder: str = (
+            "Chat with this agent here; use / for shortcuts. "
+            "Alt+Enter inserts a newline. Ctrl+T opens the last transcript."
+        )
         self._contextual_completion_help: dict[str, str] = {
             "details": "Show this agent's configuration (+ expands prompt).",
             "help": "Display this context-aware menu.",

glaip_sdk/cli/slash/prompt.py

@@ -162,6 +162,17 @@ def _create_key_bindings(_session: SlashSession) -> Any:
         if buffer.complete_state is not None:
             buffer.cancel_completion()
 
+    @bindings.add("c-t")  # type: ignore[misc]
+    def _handle_ctrl_t_key(event: Any) -> None:  # vulture: ignore
+        """Handle Ctrl+T key - open the transcript viewer (when available)."""
+        buffer = event.app.current_buffer
+        if buffer.complete_state is not None:
+            buffer.cancel_completion()
+
+        open_viewer = getattr(_session, "open_transcript_viewer", None)
+        if callable(open_viewer):
+            open_viewer(announce=True)
+
     return bindings
 
 

glaip_sdk/cli/slash/remote_runs_controller.py

@@ -30,7 +30,7 @@ from glaip_sdk.branding import (
 )
 from glaip_sdk.cli.constants import DEFAULT_REMOTE_RUNS_PAGE_LIMIT
 from glaip_sdk.cli.slash.tui.remote_runs_app import RemoteRunsTUICallbacks, run_remote_runs_textual
-from glaip_sdk.cli.utils import prompt_export_choice_questionary, questionary_safe_ask
+from glaip_sdk.cli.core.prompting import prompt_export_choice_questionary, questionary_safe_ask
 from glaip_sdk.exceptions import (
     AuthenticationError,
     ForbiddenError,

glaip_sdk/cli/slash/session.py

@@ -6,6 +6,7 @@ Authors:
 
 from __future__ import annotations
 
+import asyncio
 import importlib
 import os
 import shlex
@@ -51,19 +52,17 @@ from glaip_sdk.cli.slash.prompt import (
     to_formatted_text,
 )
 from glaip_sdk.cli.slash.remote_runs_controller import RemoteRunsController
+from glaip_sdk.cli.slash.tui.context import TUIContext
 from glaip_sdk.cli.transcript import (
     export_cached_transcript,
     load_history_snapshot,
 )
 from glaip_sdk.cli.transcript.viewer import ViewerContext, run_viewer_session
 from glaip_sdk.cli.update_notifier import maybe_notify_update
-from glaip_sdk.cli.utils import (
-    _fuzzy_pick_for_resources,
-    command_hint,
-    format_size,
-    get_client,
-    restore_slash_session_context,
-)
+from glaip_sdk.cli.core.context import get_client, restore_slash_session_context
+from glaip_sdk.cli.core.output import format_size
+from glaip_sdk.cli.core.prompting import _fuzzy_pick_for_resources
+from glaip_sdk.cli.hints import command_hint
 from glaip_sdk.rich_components import AIPGrid, AIPPanel, AIPTable
 
 SlashHandler = Callable[["SlashSession", list[str], bool], bool]
@@ -189,6 +188,7 @@ class SlashSession:
         self._update_notifier = maybe_notify_update
         self._home_hint_shown = False
         self._agent_transcript_ready: dict[str, str] = {}
+        self.tui_ctx: TUIContext | None = None
 
     # ------------------------------------------------------------------
     # Session orchestration
@@ -218,6 +218,22 @@ class SlashSession:
 
     def run(self, initial_commands: Iterable[str] | None = None) -> None:
         """Start the command palette session loop."""
+        # Initialize TUI context asynchronously
+        try:
+            self.tui_ctx = asyncio.run(TUIContext.create())
+        except RuntimeError:
+            try:
+                loop = asyncio.get_event_loop()
+            except RuntimeError:
+                self.tui_ctx = None
+            else:
+                if loop.is_running():
+                    self.tui_ctx = None
+                else:
+                    self.tui_ctx = loop.run_until_complete(TUIContext.create())
+        except Exception:
+            self.tui_ctx = None
+
         ctx_obj = self.ctx.obj if isinstance(self.ctx.obj, dict) else None
         previous_session = None
         if ctx_obj is not None:
@@ -548,7 +564,7 @@ class SlashSession:
         try:
             # Use the modern account-aware wizard directly (bypasses legacy config gating)
             _configure_interactive(account_name=None)
-            self._config_cache = None
+            self.on_account_switched()
             if self._suppress_login_layout:
                 self._welcome_rendered = False
                 self._default_actions_shown = False
@@ -1211,6 +1227,33 @@ class SlashSession:
             self._client = get_client(self.ctx)
         return self._client
 
+    def on_account_switched(self, _account_name: str | None = None) -> None:
+        """Reset any state that depends on the active account.
+
+        The active account can change via `/accounts` (or other flows that call
+        AccountStore.set_active_account). The slash session caches a configured
+        client instance, so we must invalidate it to avoid leaking the previous
+        account's API URL/key into subsequent commands like `/agents` or `/runs`.
+
+        This method clears:
+        - Client and config cache (account-specific credentials)
+        - Current agent and recent agents (agent data is account-scoped)
+        - Runs pagination state (runs are account-scoped)
+        - Active renderer and transcript ready state (UI state tied to account context)
+        - Contextual commands (may be account-specific)
+
+        These broader resets ensure a clean slate when switching accounts, preventing
+        stale data from the previous account from appearing in the new account's context.
+        """
+        self._client = None
+        self._config_cache = None
+        self._current_agent = None
+        self.recent_agents = []
+        self._runs_pagination_state.clear()
+        self.clear_active_renderer()
+        self.clear_agent_transcript_ready()
+        self.set_contextual_commands(None)
+
     def set_contextual_commands(self, commands: dict[str, str] | None, *, include_global: bool = True) -> None:
         """Set context-specific commands that should appear in completions."""
         self._contextual_commands = dict(commands or {})
@@ -1340,14 +1383,16 @@ class SlashSession:
             f"[{ACCENT_STYLE}]{agent_info['id']}[/]"
         )
         status_line = f"[{SUCCESS_STYLE}]ready[/]"
-        status_line += " · transcript ready" if transcript_status["transcript_ready"] else " · transcript pending"
+        if not transcript_status["has_transcript"]:
+            status_line += " · no transcript"
+        elif transcript_status["transcript_ready"]:
+            status_line += " · transcript ready"
+        else:
+            status_line += " · transcript pending"
         header_grid.add_row(primary_line, status_line)
 
         if agent_info["description"]:
-            description = agent_info["description"]
-            if not transcript_status["transcript_ready"]:
-                description = f"{description}  (transcript pending)"
-            header_grid.add_row(f"[dim]{description}[/dim]", "")
+            header_grid.add_row(f"[dim]{agent_info['description']}[/dim]", "")
 
         return header_grid
 

glaip_sdk/cli/slash/tui/__init__.py

@@ -1,9 +1,34 @@
 """Textual UI helpers for slash commands."""
 
+from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter, ClipboardResult
+from glaip_sdk.cli.slash.tui.context import TUIContext
+from glaip_sdk.cli.slash.tui.keybind_registry import (
+    Keybind,
+    KeybindRegistry,
+    format_key_sequence,
+    parse_key_sequence,
+)
+from glaip_sdk.cli.slash.tui.toast import ToastBus, ToastVariant
 from glaip_sdk.cli.slash.tui.remote_runs_app import (
     RemoteRunsTextualApp,
     RemoteRunsTUICallbacks,
     run_remote_runs_textual,
 )
+from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities, detect_terminal_background
 
-__all__ = ["RemoteRunsTextualApp", "RemoteRunsTUICallbacks", "run_remote_runs_textual"]
+__all__ = [
+    "TUIContext",
+    "ToastBus",
+    "ToastVariant",
+    "TerminalCapabilities",
+    "detect_terminal_background",
+    "RemoteRunsTextualApp",
+    "RemoteRunsTUICallbacks",
+    "run_remote_runs_textual",
+    "KeybindRegistry",
+    "Keybind",
+    "parse_key_sequence",
+    "format_key_sequence",
+    "ClipboardAdapter",
+    "ClipboardResult",
+]

glaip_sdk/cli/slash/tui/accounts.tcss

@@ -11,7 +11,7 @@
 
 #env-lock {
     padding: 0 1 0 1;
-    color: yellow;
+    color: $warning;
     height: 1;
 }
 
@@ -45,6 +45,7 @@
     padding: 0 1 0 1;
     margin: 0 0 0 0;
     height: 1fr;
+    border: tall $primary;
 }
 
 #status-bar {
@@ -58,11 +59,12 @@
 }
 
 #status {
-    padding: 0 1 0 1;
-    margin: 0;
-    color: cyan;
+    height: 3;
+    padding: 0 1;
+    color: $secondary;
 }
 
+
 .form-label {
     padding: 0 1 0 1;
 }
@@ -73,7 +75,7 @@
 
 #form-status, #confirm-status {
     padding: 0 1;
-    color: yellow;
+    color: $warning;
 }
 
 #form-test {

glaip_sdk/cli/slash/tui/accounts_app.py

@@ -23,7 +23,10 @@ from glaip_sdk.cli.slash.accounts_shared import (
     env_credentials_present,
 )
 from glaip_sdk.cli.slash.tui.background_tasks import BackgroundTaskMixin
+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.theme.catalog import _BUILTIN_THEMES
 from glaip_sdk.cli.validators import validate_api_key
 from glaip_sdk.utils.validation import validate_url
 
@@ -51,6 +54,13 @@ except Exception:  # pragma: no cover - optional dependency
     LoadingIndicator = None  # type: ignore[assignment]
     ModalScreen = None  # type: ignore[assignment]
     Static = None  # type: ignore[assignment]
+    Theme = None  # type: ignore[assignment]
+
+if App is not None:
+    try:  # pragma: no cover - optional dependency
+        from textual.theme import Theme
+    except Exception:  # pragma: no cover - optional dependency
+        Theme = None  # type: ignore[assignment]
 
 TEXTUAL_SUPPORTED = App is not None and DataTable is not None
 
@@ -201,11 +211,12 @@ def run_accounts_textual(
     active_account: str | None,
     env_lock: bool,
     callbacks: AccountsTUICallbacks,
+    ctx: TUIContext | None = None,
 ) -> None:
     """Launch the Textual accounts browser if dependencies are available."""
     if not TEXTUAL_SUPPORTED:
         return
-    app = AccountsTextualApp(rows, active_account, env_lock, callbacks)
+    app = AccountsTextualApp(rows, active_account, env_lock, callbacks, ctx=ctx)
     app.run()
 
 
@@ -379,16 +390,18 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
 
     CSS_PATH = CSS_FILE_NAME
     BINDINGS = [
-        Binding("enter", "switch_row", "Switch", show=True),
-        Binding("return", "switch_row", "Switch", show=False),
-        Binding("/", "focus_filter", "Filter", show=True),
-        Binding("a", "add_account", "Add", show=True),
-        Binding("e", "edit_account", "Edit", show=True),
-        Binding("d", "delete_account", "Delete", show=True),
+        Binding("enter", "switch_row", "Switch", show=True) if Binding else None,
+        Binding("return", "switch_row", "Switch", show=False) if Binding else None,
+        Binding("/", "focus_filter", "Filter", show=True) if Binding else None,
+        Binding("a", "add_account", "Add", show=True) if Binding else None,
+        Binding("e", "edit_account", "Edit", show=True) if Binding else None,
+        Binding("d", "delete_account", "Delete", show=True) if Binding else None,
+        Binding("c", "copy_account", "Copy", show=True) if Binding else None,
         # Esc clears filter when focused/non-empty; otherwise exits
-        Binding("escape", "clear_or_exit", "Close", priority=True),
-        Binding("q", "app_exit", "Close", priority=True),
+        Binding("escape", "clear_or_exit", "Close", priority=True) if Binding else None,
+        Binding("q", "app_exit", "Close", priority=True) if Binding else None,
     ]
+    BINDINGS = [b for b in BINDINGS if b is not None]
 
     def __init__(
         self,
@@ -396,6 +409,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         active_account: str | None,
         env_lock: bool,
         callbacks: AccountsTUICallbacks,
+        ctx: TUIContext | None = None,
     ) -> None:
         """Initialize the Textual accounts app.
 
@@ -404,6 +418,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             active_account: Name of the currently active account.
             env_lock: Whether environment credentials are locking account switching.
             callbacks: Callbacks for account switching operations.
+            ctx: Shared TUI context.
         """
         super().__init__()
         self._store = get_account_store()
@@ -411,6 +426,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         self._active_account = active_account
         self._env_lock = env_lock
         self._callbacks = callbacks
+        self._ctx = ctx
         self._filter_text: str = ""
         self._is_switching = False
 
@@ -449,6 +465,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
 
     def on_mount(self) -> None:
         """Configure table columns and load rows."""
+        self._apply_theme()
         table = self.query_one(ACCOUNTS_TABLE_ID, DataTable)
         table.add_column("Name", width=20)
         table.add_column("API URL", width=40)
@@ -684,6 +701,10 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             return
         self.exit()
 
+    def action_app_exit(self) -> None:
+        """Exit the application regardless of focus state."""
+        self.exit()
+
     def on_button_pressed(self, event: Button.Pressed) -> None:
         """Handle filter bar buttons."""
         if event.button.id == "filter-clear":
@@ -748,6 +769,26 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             return
         self.push_screen(ConfirmDeleteModal(name), self._on_delete_result)
 
+    def action_copy_account(self) -> None:
+        """Copy selected account name and URL to clipboard."""
+        name = self._get_selected_name()
+        if not name:
+            self._set_status("Select an account to copy.", "yellow")
+            return
+
+        account = self._store.get_account(name)
+        if not account:
+            return
+
+        text = f"Account: {name}\nURL: {account.get('api_url', '')}"
+        adapter = ClipboardAdapter()
+        result = adapter.copy(text)
+
+        if result.success:
+            self._set_status(f"Copied '{name}' to clipboard.", "green")
+        else:
+            self._set_status(f"Copy failed: {result.message}", "red")
+
     def _check_env_lock_hotkey(self) -> bool:
         """Prevent mutations when env credentials are present."""
         if not self._is_env_locked():
@@ -870,3 +911,23 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         filter_input = self.query_one(FILTER_INPUT_ID, Input)
         clear_btn = self.query_one("#filter-clear", Button)
         clear_btn.display = bool(filter_input.value or self._filter_text)
+
+    def _apply_theme(self) -> None:
+        """Register built-in themes and set the active one from context."""
+        if not self._ctx or not self._ctx.theme or Theme is None:
+            return
+
+        for name, tokens in _BUILTIN_THEMES.items():
+            self.register_theme(
+                Theme(
+                    name=name,
+                    primary=tokens.primary,
+                    secondary=tokens.secondary,
+                    accent=tokens.accent,
+                    warning=tokens.warning,
+                    error=tokens.error,
+                    success=tokens.success,
+                )
+            )
+
+        self.theme = self._ctx.theme.theme_name