glaip-sdk 0.1.2__py3-none-any.whl → 0.6.5b3__py3-none-any.whl

glaip_sdk/cli/masking.py

@@ -6,9 +6,10 @@ Authors:
 
 from __future__ import annotations
 
-import os
 from typing import Any
 
+from glaip_sdk.cli.constants import MASK_SENSITIVE_FIELDS, MASKING_ENABLED
+
 __all__ = [
     "mask_payload",
     "mask_rows",
@@ -16,20 +17,9 @@ __all__ = [
     "_mask_any",
     "_maybe_mask_row",
     "_resolve_mask_fields",
+    "mask_api_key_display",
 ]
 
-_DEFAULT_MASK_FIELDS = {
-    "api_key",
-    "apikey",
-    "token",
-    "access_token",
-    "secret",
-    "client_secret",
-    "password",
-    "private_key",
-    "bearer",
-}
-
 
 def _mask_value(raw: Any) -> str:
     """Return a masked representation of the provided value.
@@ -90,22 +80,10 @@ def _maybe_mask_row(row: dict[str, Any], mask_fields: set[str]) -> dict[str, Any
 
 
 def _resolve_mask_fields() -> set[str]:
-    """Resolve the set of sensitive fields to mask based on environment.
-
-    Returns:
-        set[str]: Set of field names to mask. Empty set if masking is disabled
-                 via AIP_MASK_OFF environment variable, custom fields from
-                 AIP_MASK_FIELDS, or default fields if neither is set.
-    """
-    if os.getenv("AIP_MASK_OFF", "0") in {"1", "true", "on", "yes"}:
+    """Return the configured set of fields that should be masked."""
+    if not MASKING_ENABLED:
         return set()
-
-    env_fields = (os.getenv("AIP_MASK_FIELDS") or "").strip()
-    if env_fields:
-        parts = [part.strip().lower() for part in env_fields.split(",") if part.strip()]
-        return set(parts)
-
-    return set(_DEFAULT_MASK_FIELDS)
+    return set(MASK_SENSITIVE_FIELDS)
 
 
 def mask_payload(payload: Any) -> Any:
@@ -115,9 +93,7 @@ def mask_payload(payload: Any) -> Any:
         payload: Any data structure (dict, list, or primitive) to mask.
 
     Returns:
-        Any: The payload with sensitive fields masked based on environment
-             configuration. Returns original payload if masking is disabled
-             or if an error occurs during masking.
+        Any: The payload with sensitive fields masked based on configuration.
     """
     mask_fields = _resolve_mask_fields()
     if not mask_fields:
@@ -136,8 +112,8 @@ def mask_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
 
     Returns:
         list[dict[str, Any]]: List of rows with sensitive fields masked based
-                              on environment configuration. Returns original
-                              rows if masking is disabled or if an error occurs.
+                              on configuration. Returns original rows if
+                              masking is disabled or if an error occurs.
     """
     mask_fields = _resolve_mask_fields()
     if not mask_fields:
@@ -146,3 +122,15 @@ def mask_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
         return [_maybe_mask_row(row, mask_fields) for row in rows]
     except Exception:
         return rows
+
+
+def mask_api_key_display(value: str | None) -> str:
+    """Mask API keys for CLI display while preserving readability for short keys."""
+    if not value:
+        return ""
+    length = len(value)
+    if length <= 4:
+        return "***"
+    if length <= 8:
+        return value[:1] + "••••" + value[-1:]
+    return value[:4] + "••••" + value[-4:]

glaip_sdk/cli/pager.py

@@ -19,6 +19,8 @@ from typing import Any
 
 from rich.console import Console
 
+from glaip_sdk.cli.constants import PAGER_HEADER_ENABLED, PAGER_MODE, PAGER_WRAP_LINES
+
 __all__ = [
     "console",
     "_prepare_pager_env",
@@ -64,8 +66,7 @@ def _prepare_pager_env(clear_on_exit: bool = True) -> None:
       -R  : pass ANSI color escapes
       -S  : chop long lines (horizontal scroll with ←/→)
     (No -F, no -X) so we open a full-screen pager and clear on exit.
-    Toggle wrapping with AIP_PAGER_WRAP=1 to drop -S.
-    Power users can override via AIP_LESS_FLAGS.
+    Toggle wrapping via `PAGER_WRAP_LINES` (True drops -S).
 
     Args:
         clear_on_exit: Whether to clear the pager on exit (default: True)
@@ -75,10 +76,9 @@ def _prepare_pager_env(clear_on_exit: bool = True) -> None:
     """
     os.environ.pop("LESSSECURE", None)
     if os.getenv("LESS") is None:
-        want_wrap = os.getenv("AIP_PAGER_WRAP", "0") == "1"
-        base = "-R" if want_wrap else "-RS"
+        base = "-R" if PAGER_WRAP_LINES else "-RS"
         default_flags = base if clear_on_exit else (base + "FX")
-        os.environ["LESS"] = os.getenv("AIP_LESS_FLAGS", default_flags)
+        os.environ["LESS"] = default_flags
 
 
 def _render_ansi(renderable: Any) -> str:
@@ -111,8 +111,7 @@ def _pager_header() -> str:
     Returns:
         str: Header text containing navigation help, or empty string if disabled
     """
-    v = (os.getenv("AIP_PAGER_HEADER", "1") or "1").strip().lower()
-    if v in {"0", "false", "off"}:
+    if not PAGER_HEADER_ENABLED:
         return ""
     return "\n".join(
         [
@@ -254,10 +253,10 @@ def _should_page_output(row_count: int, is_tty: bool) -> bool:
         bool: True if output should be paginated, False otherwise
     """
     active_console = _get_console()
-    pager_env = (os.getenv("AIP_PAGER", "auto") or "auto").lower()
-    if pager_env in ("0", "off", "false"):
+    pager_mode = (PAGER_MODE or "auto").lower()
+    if pager_mode in ("0", "off", "false"):
         return False
-    if pager_env in ("1", "on", "true"):
+    if pager_mode in ("1", "on", "true"):
         return is_tty
     try:
         term_h = active_console.size.height or 24

glaip_sdk/cli/parsers/__init__.py

@@ -4,6 +4,4 @@ Authors:
     Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
 """
 
-from glaip_sdk.cli.parsers.json_input import parse_json_input
-
-__all__ = ["parse_json_input"]
+__all__: list[str] = []

glaip_sdk/cli/slash/__init__.py

@@ -6,19 +6,10 @@ Authors:
 
 from glaip_sdk.cli.commands.agents import get as agents_get_command
 from glaip_sdk.cli.commands.agents import run as agents_run_command
-from glaip_sdk.cli.commands.configure import configure_command, load_config
-from glaip_sdk.cli.slash.agent_session import AgentRunSession
-from glaip_sdk.cli.slash.prompt import _HAS_PROMPT_TOOLKIT
 from glaip_sdk.cli.slash.session import SlashSession
-from glaip_sdk.cli.utils import get_client
 
 __all__ = [
-    "AgentRunSession",
     "SlashSession",
-    "_HAS_PROMPT_TOOLKIT",
     "agents_get_command",
     "agents_run_command",
-    "configure_command",
-    "get_client",
-    "load_config",
 ]

glaip_sdk/cli/slash/accounts_controller.py

@@ -0,0 +1,500 @@
+"""Accounts controller for the /accounts slash command.
+
+Provides a lightweight Textual list with fallback Rich snapshot to switch
+between stored accounts using the shared AccountStore and CLI validation.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Iterable
+from getpass import getpass
+from typing import TYPE_CHECKING, Any
+
+from rich.console import Console
+from rich.prompt import Prompt
+
+from glaip_sdk.branding import ERROR_STYLE, INFO_STYLE, SUCCESS_STYLE, WARNING_STYLE
+from glaip_sdk.cli.account_store import AccountStore, AccountStoreError, get_account_store
+from glaip_sdk.cli.commands.common_config import check_connection_with_reason
+from glaip_sdk.cli.masking import mask_api_key_display
+from glaip_sdk.cli.validators import validate_api_key
+from glaip_sdk.cli.slash.accounts_shared import (
+    build_account_rows,
+    build_account_status_string,
+    env_credentials_present,
+)
+from glaip_sdk.cli.slash.tui.accounts_app import TEXTUAL_SUPPORTED, AccountsTUICallbacks, run_accounts_textual
+from glaip_sdk.rich_components import AIPPanel, AIPTable
+from glaip_sdk.utils.validation import validate_url
+
+if TYPE_CHECKING:  # pragma: no cover
+    from glaip_sdk.cli.slash.session import SlashSession
+
+TEXTUAL_AVAILABLE = bool(TEXTUAL_SUPPORTED)
+
+
+class AccountsController:
+    """Controller for listing and switching accounts inside the palette."""
+
+    def __init__(self, session: SlashSession) -> None:
+        """Initialize the accounts controller.
+
+        Args:
+            session: The slash session context.
+        """
+        self.session = session
+        self.console: Console = session.console
+        self.ctx = session.ctx
+
+    def handle_accounts_command(self, args: list[str]) -> bool:
+        """Handle `/accounts` with optional `/accounts <name>` quick switch."""
+        store = get_account_store()
+        env_lock = env_credentials_present(partial=True)
+        accounts = store.list_accounts()
+
+        if not accounts:
+            self.console.print(f"[{WARNING_STYLE}]No accounts found. Use `/login` to add credentials.[/]")
+            return self.session._continue_session()
+
+        if args:
+            name = args[0]
+            self._switch_account(store, name, env_lock)
+            return self.session._continue_session()
+
+        rows = self._build_rows(accounts, store.get_active_account(), env_lock)
+
+        if self._should_use_textual():
+            self._render_textual(rows, store, env_lock)
+        else:
+            self._render_rich_interactive(store, env_lock)
+
+        return self.session._continue_session()
+
+    def _should_use_textual(self) -> bool:
+        """Return whether Textual UI should be used."""
+        if not TEXTUAL_AVAILABLE:
+            return False
+
+        def _is_tty(stream: Any) -> bool:
+            isatty = getattr(stream, "isatty", None)
+            if not callable(isatty):
+                return False
+            try:
+                return bool(isatty())
+            except Exception:
+                return False
+
+        return _is_tty(sys.stdin) and _is_tty(sys.stdout)
+
+    def _build_rows(
+        self,
+        accounts: dict[str, dict[str, str]],
+        active_account: str | None,
+        env_lock: bool,
+    ) -> list[dict[str, str | bool]]:
+        """Normalize account rows for display."""
+        return build_account_rows(accounts, active_account, env_lock)
+
+    def _render_rich(self, rows: Iterable[dict[str, str | bool]], env_lock: bool) -> None:
+        """Render a Rich snapshot with columns matching TUI."""
+        if env_lock:
+            self.console.print(
+                f"[{WARNING_STYLE}]Env credentials detected (AIP_API_URL/AIP_API_KEY); add/edit/delete are disabled.[/]"
+            )
+
+        table = AIPTable(title="AIP Accounts")
+        table.add_column("Name", style=INFO_STYLE, width=20)
+        table.add_column("API URL", style=SUCCESS_STYLE, width=40)
+        table.add_column("Key (masked)", style="dim", width=20)
+        table.add_column("Status", style=SUCCESS_STYLE, width=14)
+
+        for row in rows:
+            status = build_account_status_string(row, use_markup=True)
+            # pylint: disable=duplicate-code
+            # Similar to accounts_app.py but uses Rich AIPTable API
+            table.add_row(
+                str(row.get("name", "")),
+                str(row.get("api_url", "")),
+                str(row.get("masked_key", "")),
+                status,
+            )
+
+        self.console.print(table)
+
+    def _render_rich_interactive(self, store: AccountStore, env_lock: bool) -> None:
+        """Render Rich snapshot and run linear add/edit/delete prompts."""
+        if env_lock:
+            rows = self._build_rows(store.list_accounts(), store.get_active_account(), env_lock)
+            self._render_rich(rows, env_lock)
+            return
+
+        while True:  # pragma: no cover - interactive prompt loop
+            rows = self._build_rows(store.list_accounts(), store.get_active_account(), env_lock)
+            self._render_rich(rows, env_lock)
+            action = self._prompt_action()
+            if action == "q":
+                break
+            if action == "a":
+                self._rich_add_flow(store)
+            elif action == "e":
+                self._rich_edit_flow(store)
+            elif action == "d":
+                self._rich_delete_flow(store)
+            elif action == "s":
+                self._rich_switch_flow(store, env_lock)
+            else:
+                self.console.print(f"[{WARNING_STYLE}]Invalid choice. Use a/e/d/s/q.[/]")
+
+    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 = 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"
+        if active_after != active:
+            host_after = ""
+            account_after = store.get_account(active_after) 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}",
+                    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)."""
+        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
+
+        account = store.get_account(name)
+        if not account:
+            msg = f"Account '{name}' not found."
+            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            return False, msg
+
+        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
+
+        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
+
+        try:
+            store.set_active_account(name)
+            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,
+                )
+            )
+            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}[/]")
+            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}[/]")
+            return False, msg
+
+    @staticmethod
+    def _parse_error_reason(reason: str | None) -> tuple[str, str]:
+        """Parse error reason into (code, detail) to avoid fragile substring checks."""
+        if not reason:
+            return "", ""
+        if ":" in reason:
+            code, _, detail = reason.partition(":")
+            return code.strip(), detail.strip()
+        return reason.strip(), ""
+
+    def _prompt_action(self) -> str:
+        """Prompt for add/edit/delete/quit action."""
+        try:
+            choice = Prompt.ask("(a)dd / (e)dit / (d)elete / (s)witch / (q)uit", default="q")
+        except Exception:  # pragma: no cover - defensive around prompt failures
+            return "q"
+        return (choice or "").strip().lower()[:1]
+
+    def _prompt_yes_no(self, prompt: str, *, default: bool = True) -> bool:
+        """Prompt a yes/no question with a default."""
+        default_str = "Y/n" if default else "y/N"
+        try:
+            answer = Prompt.ask(f"{prompt} ({default_str})", default="y" if default else "n")
+        except Exception:  # pragma: no cover - defensive around prompt failures
+            return default
+        normalized = (answer or "").strip().lower()
+        if not normalized:
+            return default
+        return normalized in {"y", "yes"}
+
+    def _prompt_account_name(self, store: AccountStore, *, for_edit: bool) -> str | None:
+        """Prompt for an account name, validating per store rules."""
+        while True:  # pragma: no cover - interactive prompt loop
+            name = self._get_name_input(for_edit)
+            if name is None:
+                return None
+            if not name:
+                self.console.print(f"[{WARNING_STYLE}]Name is required.[/]")
+                continue
+            if not self._validate_name_format(store, name):
+                continue
+            if not self._validate_name_existence(store, name, for_edit):
+                continue
+            return name
+
+    def _get_name_input(self, for_edit: bool) -> str | None:
+        """Get account name input from user."""
+        try:
+            prompt_text = "Account name" + (" (existing)" if for_edit else "")
+            name = Prompt.ask(prompt_text)
+            return name.strip() if name else None
+        except Exception:
+            return None
+
+    def _validate_name_format(self, store: AccountStore, name: str) -> bool:
+        """Validate account name format."""
+        try:
+            store.validate_account_name(name)
+            return True
+        except Exception as exc:
+            self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
+            return False
+
+    def _validate_name_existence(self, store: AccountStore, name: str, for_edit: bool) -> bool:
+        """Validate account name existence based on mode."""
+        account_exists = store.get_account(name) is not None
+        if not for_edit and account_exists:
+            self.console.print(
+                f"[{WARNING_STYLE}]Account '{name}' already exists. Use edit instead or choose a new name.[/]"
+            )
+            return False
+        if for_edit and not account_exists:
+            self.console.print(f"[{WARNING_STYLE}]Account '{name}' not found. Try again or quit.[/]")
+            return False
+        return True
+
+    def _prompt_api_url(self, existing_url: str | None = None) -> str | None:
+        """Prompt for API URL with HTTPS validation."""
+        placeholder = existing_url or "https://your-aip-instance.com"
+        while True:  # pragma: no cover - interactive prompt loop
+            try:
+                entered = Prompt.ask("API URL", default=placeholder)
+            except Exception:
+                return None
+            url = (entered or "").strip()
+            if not url and existing_url:
+                return existing_url
+            if not url:
+                self.console.print(f"[{WARNING_STYLE}]API URL is required.[/]")
+                continue
+            try:
+                return validate_url(url)
+            except Exception as exc:
+                self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
+
+    def _prompt_api_key(self, existing_key: str | None = None) -> str | None:
+        """Prompt for API key (masked)."""
+        mask_hint = "leave blank to keep current" if existing_key else None
+        while True:  # pragma: no cover - interactive prompt loop
+            try:
+                entered = getpass(f"API key ({mask_hint or 'input hidden'}): ")
+            except Exception:
+                return None
+            if not entered and existing_key:
+                return existing_key
+            if not entered:
+                self.console.print(f"[{WARNING_STYLE}]API key is required.[/]")
+                continue
+            try:
+                return validate_api_key(entered)
+            except Exception as exc:
+                self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
+
+    def _rich_add_flow(self, store: AccountStore) -> None:
+        """Run Rich add prompts and save."""
+        name = self._prompt_account_name(store, for_edit=False)
+        if not name:
+            return
+        api_url = self._prompt_api_url()
+        if not api_url:
+            return
+        api_key = self._prompt_api_key()
+        if not api_key:
+            return
+        should_test = self._prompt_yes_no("Test connection before save?", default=True)
+        self._save_account(store, name, api_url, api_key, should_test, True, is_edit=False)
+
+    def _rich_edit_flow(self, store: AccountStore) -> None:
+        """Run Rich edit prompts and save."""
+        name = self._prompt_account_name(store, for_edit=True)
+        if not name:
+            return
+        existing = store.get_account(name) or {}
+        api_url = self._prompt_api_url(existing.get("api_url"))
+        if not api_url:
+            return
+        api_key = self._prompt_api_key(existing.get("api_key"))
+        if not api_key:
+            return
+        should_test = self._prompt_yes_no("Test connection before save?", default=True)
+        self._save_account(store, name, api_url, api_key, should_test, False, is_edit=True)
+
+    def _rich_switch_flow(self, store: AccountStore, env_lock: bool) -> None:
+        """Run Rich switch prompt and set active account."""
+        name = self._prompt_account_name(store, for_edit=True)
+        if not name:
+            return
+        self._switch_account(store, name, env_lock)
+
+    def _save_account(
+        self,
+        store: AccountStore,
+        name: str,
+        api_url: str,
+        api_key: str,
+        should_test: bool,
+        set_active: bool,
+        *,
+        is_edit: bool,
+    ) -> None:
+        """Validate, optionally test, and persist account changes."""
+        if should_test and not self._run_connection_test_with_retry(api_url, api_key):
+            return
+
+        try:
+            store.add_account(name, api_url, api_key, overwrite=is_edit)
+        except AccountStoreError as exc:
+            self.console.print(f"[{ERROR_STYLE}]Save failed: {exc}[/]")
+            return
+        except Exception as exc:
+            self.console.print(f"[{ERROR_STYLE}]Unexpected error while saving: {exc}[/]")
+            return
+
+        self.console.print(f"[{SUCCESS_STYLE}]Account '{name}' saved.[/]")
+        if set_active:
+            try:
+                store.set_active_account(name)
+            except Exception as exc:
+                self.console.print(f"[{WARNING_STYLE}]Account saved but could not set active: {exc}[/]")
+            else:
+                self._announce_active_change(store, name)
+
+    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.[/]")
+        while True:  # pragma: no cover - interactive prompt loop
+            confirmation = Prompt.ask("Confirm name (or blank to cancel)", default="")
+            if confirmation is None or not confirmation.strip():
+                self.console.print(f"[{WARNING_STYLE}]Deletion cancelled.[/]")
+                return False
+            if confirmation.strip() != name:
+                self.console.print(f"[{WARNING_STYLE}]Name does not match; type '{name}' to confirm.[/]")
+                continue
+            return True
+
+    def _delete_account_and_notify(self, store: AccountStore, name: str, active_before: str | None) -> None:
+        """Remove account with error handling and announce active change."""
+        try:
+            store.remove_account(name)
+        except AccountStoreError as exc:
+            self.console.print(f"[{ERROR_STYLE}]Delete failed: {exc}[/]")
+            return
+        except Exception as exc:
+            self.console.print(f"[{ERROR_STYLE}]Unexpected error while deleting: {exc}[/]")
+            return
+
+        self.console.print(f"[{SUCCESS_STYLE}]Account '{name}' deleted.[/]")
+        # Announce active account change if it changed
+        active_after = store.get_active_account()
+        if active_after is not None and active_after != active_before:
+            self._announce_active_change(store, active_after)
+        elif active_after is None and active_before == name:
+            self.console.print(f"[{WARNING_STYLE}]No account is currently active. Select an account to activate it.[/]")
+
+    def _rich_delete_flow(self, store: AccountStore) -> None:
+        """Run Rich delete prompts with name confirmation."""
+        name = self._prompt_account_name(store, for_edit=True)
+        if not name:
+            return
+
+        # Check if this is the last remaining account before prompting for confirmation
+        accounts = store.list_accounts()
+        if len(accounts) <= 1 and name in accounts:
+            self.console.print(f"[{WARNING_STYLE}]Cannot remove the last remaining account.[/]")
+            return
+
+        if not self._confirm_delete_prompt(name):
+            return
+
+        # Re-check after confirmation prompt (race condition guard)
+        accounts = store.list_accounts()
+        if len(accounts) <= 1 and name in accounts:
+            self.console.print(f"[{WARNING_STYLE}]Cannot remove the last remaining account.[/]")
+            return
+
+        active_before = store.get_active_account()
+        self._delete_account_and_notify(store, name, active_before)
+
+    def _format_connection_failure(self, code: str, detail: str, api_url: str) -> str:
+        """Build a user-facing connection failure message."""
+        detail_suffix = f": {detail}" if detail else ""
+        if code == "connection_failed":
+            return f"Connection test failed: cannot reach {api_url}{detail_suffix}"
+        if code == "api_failed":
+            return f"Connection test failed: API error{detail_suffix}"
+        return f"Connection test failed{detail_suffix}"
+
+    def _run_connection_test_with_retry(self, api_url: str, api_key: str) -> bool:
+        """Run connection test with retry/skip prompts."""
+        skip_prompt_shown = False
+        while True:
+            ok, reason = check_connection_with_reason(api_url, api_key, abort_on_error=False)
+            if ok:
+                return True
+            code, detail = self._parse_error_reason(reason)
+            message = self._format_connection_failure(code, detail, api_url)
+            self.console.print(f"[{WARNING_STYLE}]{message}[/]")
+            retry = self._prompt_yes_no("Retry connection test?", default=True)
+            if retry:
+                continue
+            if not skip_prompt_shown:
+                skip_prompt_shown = True
+                skip = self._prompt_yes_no("Skip connection test and save?", default=False)
+                if skip:
+                    return True
+            self.console.print(f"[{WARNING_STYLE}]Cancelled save after failed connection test.[/]")
+            return False
+
+    def _announce_active_change(self, store: AccountStore, name: str) -> None:
+        """Print active account change announcement."""
+        account = store.get_account(name) or {}
+        host = account.get("api_url", "")
+        host_suffix = f" • {host}" if host else ""
+        self.console.print(f"[{SUCCESS_STYLE}]Active account ➜ {name}{host_suffix}[/]")