glaip-sdk 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

glaip_sdk/agents/base.py

@@ -44,6 +44,7 @@ from __future__ import annotations
 
 import inspect
 import logging
+import warnings
 from collections.abc import AsyncGenerator
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -127,16 +128,8 @@ class Agent:
         agents: list | None = None,
         mcps: list | None = None,
         model: str | None = _UNSET,  # type: ignore[assignment]
-        timeout: int | None = _UNSET,  # type: ignore[assignment]
-        metadata: dict[str, Any] | None = _UNSET,  # type: ignore[assignment]
-        framework: str | None = _UNSET,  # type: ignore[assignment]
-        version: str | None = _UNSET,  # type: ignore[assignment]
-        agent_type: str | None = _UNSET,  # type: ignore[assignment]
-        agent_config: dict[str, Any] | None = _UNSET,  # type: ignore[assignment]
-        tool_configs: dict[str, Any] | None = _UNSET,  # type: ignore[assignment]
-        mcp_configs: dict[str, Any] | None = _UNSET,  # type: ignore[assignment]
-        a2a_profile: dict[str, Any] | None = _UNSET,  # type: ignore[assignment]
         _client: Any = None,
+        **kwargs: Any,
     ) -> None:
         """Initialize an Agent.
 
@@ -152,16 +145,17 @@ class Agent:
             agents: List of sub-agents (Agent classes, instances, or strings).
             mcps: List of MCPs.
             model: Model identifier.
-            timeout: Execution timeout in seconds.
-            metadata: Optional metadata dictionary.
-            framework: Agent framework identifier.
-            version: Agent version string.
-            agent_type: Agent type identifier.
-            agent_config: Agent execution configuration.
-            tool_configs: Per-tool configuration overrides.
-            mcp_configs: Per-MCP configuration overrides.
-            a2a_profile: A2A profile configuration.
             _client: Internal client reference (set automatically).
+            **kwargs: Additional configuration parameters:
+                - timeout: Execution timeout in seconds.
+                - metadata: Optional metadata dictionary.
+                - framework: Agent framework identifier.
+                - version: Agent version string.
+                - agent_type: Agent type identifier.
+                - agent_config: Agent execution configuration.
+                - tool_configs: Per-tool configuration overrides.
+                - mcp_configs: Per-MCP configuration overrides.
+                - a2a_profile: A2A profile configuration.
         """
         # Instance attributes for deployed agents
         self._id = id
@@ -178,15 +172,24 @@ class Agent:
         self._mcps = mcps
         self._model = model
         self._language_model_id: str | None = None
-        self._timeout = timeout
-        self._metadata = metadata
-        self._framework = framework
-        self._version = version
-        self._agent_type = agent_type
-        self._agent_config = agent_config
-        self._tool_configs = tool_configs
-        self._mcp_configs = mcp_configs
-        self._a2a_profile = a2a_profile
+        # Extract parameters from kwargs with _UNSET defaults
+        self._timeout = kwargs.pop("timeout", Agent._UNSET)  # type: ignore[assignment]
+        self._metadata = kwargs.pop("metadata", Agent._UNSET)  # type: ignore[assignment]
+        self._framework = kwargs.pop("framework", Agent._UNSET)  # type: ignore[assignment]
+        self._version = kwargs.pop("version", Agent._UNSET)  # type: ignore[assignment]
+        self._agent_type = kwargs.pop("agent_type", Agent._UNSET)  # type: ignore[assignment]
+        self._agent_config = kwargs.pop("agent_config", Agent._UNSET)  # type: ignore[assignment]
+        self._tool_configs = kwargs.pop("tool_configs", Agent._UNSET)  # type: ignore[assignment]
+        self._mcp_configs = kwargs.pop("mcp_configs", Agent._UNSET)  # type: ignore[assignment]
+        self._a2a_profile = kwargs.pop("a2a_profile", Agent._UNSET)  # type: ignore[assignment]
+
+        # Warn about unexpected kwargs
+        if kwargs:
+            warnings.warn(
+                f"Unexpected keyword arguments: {list(kwargs.keys())}. These will be ignored.",
+                UserWarning,
+                stacklevel=2,
+            )
 
     # ─────────────────────────────────────────────────────────────────
     # Properties (override in subclasses OR pass to __init__)
@@ -880,13 +883,17 @@ class Agent:
         agent_client = getattr(self._client, "agents", self._client)
         response = agent_client.update_agent(agent_id=self.id, **kwargs)
 
-        # Update local properties from response
-        if hasattr(response, "name") and response.name:
-            self.name = response.name
-        if hasattr(response, "instruction") and response.instruction:
-            self.instruction = response.instruction
-        if hasattr(response, "updated_at"):
-            self.updated_at = response.updated_at
+        # Update local properties from response (read-only props via private attrs)
+        name = getattr(response, "name", None)
+        if name:
+            self._name = name
+
+        instruction = getattr(response, "instruction", None)
+        if instruction:
+            self._instruction = instruction
+
+        # Populate remaining fields like description, metadata, updated_at, etc.
+        type(self)._populate_from_response(self, response)
 
         return self
 

glaip_sdk/cli/commands/common_config.py

@@ -1,6 +1,7 @@
 """Shared helpers for configuration/account flows."""
 
 import click
+import logging
 from rich.console import Console
 from rich.text import Text
 
@@ -63,3 +64,38 @@ def check_connection(
     finally:
         if client is not None:
             client.close()
+
+
+def check_connection_with_reason(
+    api_url: str,
+    api_key: str,
+    *,
+    abort_on_error: bool = False,
+) -> tuple[bool, str]:
+    """Test connectivity and return structured reason."""
+    client: Client | None = None
+    try:
+        # Import lazily so test patches targeting glaip_sdk.Client are honored
+        from importlib import import_module  # noqa: PLC0415
+
+        client_module = import_module("glaip_sdk")
+        client = client_module.Client(api_url=api_url, api_key=api_key)
+        try:
+            client.list_agents()
+            return True, ""
+        except Exception as exc:  # pragma: no cover - API failures depend on network
+            if abort_on_error:
+                raise click.Abort() from exc
+            return False, f"api_failed: {exc}"
+    except Exception as exc:
+        # Log unexpected exceptions in debug while keeping CLI-friendly messaging
+        logging.getLogger(__name__).debug("Unexpected connection error", exc_info=exc)
+        if abort_on_error:
+            raise click.Abort() from exc
+        return False, f"connection_failed: {exc}"
+    finally:
+        if client is not None:
+            try:
+                client.close()
+            except Exception:
+                pass

glaip_sdk/cli/config.py

@@ -12,15 +12,26 @@ from typing import Any
 import yaml
 
 _ENV_CONFIG_DIR = os.getenv("AIP_CONFIG_DIR")
-_TEST_ENV = os.getenv("PYTEST_CURRENT_TEST") or os.getenv("PYTEST_XDIST_WORKER")
+# Detect pytest environment: check for pytest markers or test session
+# This provides automatic test isolation even if conftest.py doesn't set AIP_CONFIG_DIR
+# Note: conftest.py sets AIP_CONFIG_DIR before imports, which takes precedence
+_TEST_ENV = os.getenv("PYTEST_CURRENT_TEST") or os.getenv("PYTEST_XDIST_WORKER") or os.getenv("_PYTEST_RAISE")
 
 if _ENV_CONFIG_DIR:
+    # Explicit override via environment variable (highest priority)
+    # This is set by conftest.py before imports, ensuring test isolation
     CONFIG_DIR = Path(_ENV_CONFIG_DIR)
 elif _TEST_ENV:
     # Isolate test runs (including xdist workers) from the real user config directory
+    # Use a per-process unique temp directory to avoid conflicts in parallel test runs
     import tempfile
+    import uuid
 
-    CONFIG_DIR = Path(tempfile.gettempdir()) / "aip-test-config"
+    # Create a unique temp dir per test process to avoid conflicts
+    temp_base = Path(tempfile.gettempdir())
+    test_config_dir = temp_base / f"aip-test-config-{os.getpid()}-{uuid.uuid4().hex[:8]}"
+    CONFIG_DIR = test_config_dir
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
 else:  # pragma: no cover - default path used outside test runs
     CONFIG_DIR = Path.home() / ".aip"
 

glaip_sdk/cli/main.py

@@ -49,6 +49,24 @@ from glaip_sdk.config.constants import (
 from glaip_sdk.icons import ICON_AGENT
 from glaip_sdk.rich_components import AIPPanel, AIPTable
 
+
+def _suppress_chatty_loggers() -> None:
+    """Silence noisy SDK/httpx logs for CLI output."""
+    noisy_loggers = [
+        "glaip_sdk.client",
+        "httpx",
+        "httpcore",
+    ]
+    for name in noisy_loggers:
+        logger = logging.getLogger(name)
+        # Respect existing configuration: only raise level when unset,
+        # and avoid changing propagation if a custom handler is already attached.
+        if logger.level == logging.NOTSET:
+            logger.setLevel(logging.WARNING)
+        if not logger.handlers:
+            logger.propagate = False
+
+
 # Import SlashSession for potential mocking in tests
 try:
     from glaip_sdk.cli.slash import SlashSession
@@ -123,6 +141,8 @@ def main(
     ctx.obj["view"] = view
     ctx.obj["account_name"] = account_name
 
+    _suppress_chatty_loggers()
+
     ctx.obj["tty"] = not no_tty
 
     launching_slash = (

glaip_sdk/cli/slash/accounts_controller.py

@@ -0,0 +1,217 @@
+"""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 os
+import sys
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any
+
+from rich.console import Console
+
+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.slash.accounts_shared import build_account_status_string
+from glaip_sdk.cli.slash.tui.accounts_app import TEXTUAL_SUPPORTED, AccountsTUICallbacks, run_accounts_textual
+from glaip_sdk.rich_components import AIPPanel, AIPTable
+
+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 = bool(os.getenv("AIP_API_URL") or os.getenv("AIP_API_KEY"))
+        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(rows, 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."""
+        rows: list[dict[str, str | bool]] = []
+        for name, account in sorted(accounts.items()):
+            rows.append(
+                {
+                    "name": name,
+                    "api_url": account.get("api_url", ""),
+                    "masked_key": mask_api_key_display(account.get("api_key", "")),
+                    "active": name == active_account,
+                    "env_lock": env_lock,
+                }
+            )
+        return rows
+
+    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); switching is 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_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: show active account + host after closing the TUI
+        active_after = store.get_active_account() or "default"
+        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(f"[dim]Active account: {active_after}{host_suffix}[/]")
+        # Surface a success banner when a switch occurred inside the TUI
+        if active_after != active:
+            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(), ""

glaip_sdk/cli/slash/accounts_shared.py

@@ -0,0 +1,19 @@
+"""Shared helpers for palette `/accounts`.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def build_account_status_string(row: dict[str, Any], *, use_markup: bool = False) -> str:
+    """Build status string for an account row (active/env-lock)."""
+    status_parts: list[str] = []
+    if row.get("active"):
+        status_parts.append("[bold green]● active[/]" if use_markup else "● active")
+    if row.get("env_lock"):
+        status_parts.append("[yellow]🔒 env-lock[/]" if use_markup else "🔒 env-lock")
+    return " · ".join(status_parts)

glaip_sdk/cli/slash/session.py

@@ -34,10 +34,12 @@ from glaip_sdk.branding import (
     AIPBranding,
 )
 from glaip_sdk.cli.auth import resolve_api_url_from_context
+from glaip_sdk.cli.account_store import get_account_store
 from glaip_sdk.cli.commands import transcripts as transcripts_cmd
-from glaip_sdk.cli.commands.configure import configure_command, load_config
+from glaip_sdk.cli.commands.configure import _configure_interactive, load_config
 from glaip_sdk.cli.commands.update import update_command
 from glaip_sdk.cli.hints import format_command_hint
+from glaip_sdk.cli.slash.accounts_controller import AccountsController
 from glaip_sdk.cli.slash.agent_session import AgentRunSession
 from glaip_sdk.cli.slash.prompt import (
     FormattedText,
@@ -98,6 +100,12 @@ NEW_QUICK_ACTIONS: tuple[dict[str, Any], ...] = (
 
 
 DEFAULT_QUICK_ACTIONS: tuple[dict[str, Any], ...] = (
+    {
+        "cli": None,
+        "slash": "accounts",
+        "description": "Switch account profile",
+        "priority": 5,
+    },
     {
         "cli": "status",
         "slash": "status",
@@ -452,7 +460,8 @@ class SlashSession:
         """
         self.console.print(f"[{ACCENT_STYLE}]Launching configuration wizard...[/]")
         try:
-            self.ctx.invoke(configure_command)
+            # Use the modern account-aware wizard directly (bypasses legacy config gating)
+            _configure_interactive(account_name=None)
             self._config_cache = None
             if self._suppress_login_layout:
                 self._welcome_rendered = False
@@ -655,6 +664,11 @@ class SlashSession:
         controller = RemoteRunsController(self)
         return controller.handle_runs_command(args)
 
+    def _cmd_accounts(self, args: list[str], _invoked_from_agent: bool) -> bool:
+        """Handle the /accounts command for listing and switching accounts."""
+        controller = AccountsController(self)
+        return controller.handle_accounts_command(args)
+
     def _cmd_agents(self, args: list[str], _invoked_from_agent: bool) -> bool:
         """Handle the /agents command.
 
@@ -742,6 +756,7 @@ class SlashSession:
             hints.append((f"/agents {agent_id}", f"Reopen {agent_label}"))
         hints.extend(
             [
+                ("/accounts", "Switch account"),
                 (self.AGENTS_COMMAND, "Browse agents"),
                 (self.STATUS_COMMAND, "Check connection"),
             ]
@@ -796,6 +811,13 @@ class SlashSession:
                 handler=SlashSession._cmd_status,
             )
         )
+        self._register(
+            SlashCommand(
+                name="accounts",
+                help="✨ NEW · Browse and switch stored accounts (Textual with Rich fallback).",
+                handler=SlashSession._cmd_accounts,
+            )
+        )
         self._register(
             SlashCommand(
                 name="transcripts",
@@ -1262,13 +1284,26 @@ class SlashSession:
         """Render the main AIP environment header."""
         config = self._load_config()
 
+        account_name, account_host, env_lock = self._get_account_context()
         api_url = self._get_api_url(config)
-        status = "Configured" if config.get("api_key") else "Not configured"
 
-        segments = [
-            f"[dim]Base URL[/dim] • {api_url or 'Not configured'}",
-            f"[dim]Credentials[/dim] • {status}",
-        ]
+        host_display = account_host or "Not configured"
+        account_segment = f"[dim]Account[/dim] • {account_name} ({host_display})"
+        if env_lock:
+            account_segment += " 🔒"
+
+        segments = [account_segment]
+
+        if api_url:
+            base_label = "[dim]Base URL[/dim]"
+            if env_lock:
+                base_label = "[dim]Base URL (env)[/dim]"
+            # Always show Base URL when env-lock is active to reveal overrides
+            if env_lock or api_url != account_host:
+                segments.append(f"{base_label} • {api_url}")
+        elif not api_url:
+            segments.append("[dim]Base URL[/dim] • Not configured")
+
         agent_info = self._build_agent_status_line(active_agent)
         if agent_info:
             segments.append(agent_info)
@@ -1295,6 +1330,21 @@ class SlashSession:
         """Get the API URL from context or account store (CLI/palette ignores env credentials)."""
         return resolve_api_url_from_context(self.ctx)
 
+    def _get_account_context(self) -> tuple[str, str, bool]:
+        """Return active account name, host, and env-lock flag."""
+        try:
+            store = get_account_store()
+            active = store.get_active_account() or "default"
+            account = store.get_account(active) if hasattr(store, "get_account") else None
+            host = ""
+            if account:
+                host = account.get("api_url", "")
+            env_lock = bool(os.getenv("AIP_API_URL") or os.getenv("AIP_API_KEY"))
+            return active, host, env_lock
+        except Exception:
+            env_lock = bool(os.getenv("AIP_API_URL") or os.getenv("AIP_API_KEY"))
+            return "default", "", env_lock
+
     def _build_agent_status_line(self, active_agent: Any | None) -> str | None:
         """Return a short status line about the active or recent agent."""
         if active_agent is not None:

glaip_sdk/cli/slash/tui/accounts.tcss

@@ -0,0 +1,54 @@
+/* Styling for /accounts Textual UI
+ *
+ * Keep layout compact: filter sits tight above the table; header shows active account.
+ */
+
+#header-info {
+    padding: 0 1 0 1;
+    margin: 0;
+    height: 1;
+}
+
+#env-lock {
+    padding: 0 1 0 1;
+    color: yellow;
+    height: 1;
+}
+
+#filter-container {
+    padding: 0 1 0 1;
+    margin: 0 0 0 0;
+    height: auto;
+}
+
+#filter-label {
+    height: 1;
+}
+
+#filter-input {
+    padding: 0 1 0 1;
+    margin: 0;
+    height: 3;
+}
+
+#accounts-table {
+    padding: 0 1 0 1;
+    margin: 0 0 0 0;
+    height: 1fr;
+}
+
+#status-bar {
+    height: 3;
+    padding: 0 1;
+}
+
+#accounts-loading {
+    width: 8;
+    display: none;
+}
+
+#status {
+    padding: 0 1 0 1;
+    margin: 0;
+    color: cyan;
+}