glaip-sdk 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

glaip_sdk/cli/commands/common_config.py

@@ -0,0 +1,65 @@
+"""Shared helpers for configuration/account flows."""
+
+import click
+from rich.console import Console
+from rich.text import Text
+
+from glaip_sdk import Client
+from glaip_sdk.branding import PRIMARY, SUCCESS_STYLE, WARNING_STYLE, AIPBranding
+from glaip_sdk.cli.utils import sdk_version
+
+
+def render_branding_header(console: Console, rule_text: str) -> None:
+    """Render the standard CLI branding header with a custom rule text."""
+    branding = AIPBranding.create_from_sdk(sdk_version=sdk_version(), package_name="glaip-sdk")
+    heading = "[bold]>_ GDP Labs AI Agents Package (AIP CLI)[/bold]"
+    console.print(heading)
+    console.print()
+    console.print(branding.get_welcome_banner())
+    console.rule(rule_text, style=PRIMARY)
+
+
+def check_connection(
+    api_url: str,
+    api_key: str,
+    console: Console,
+    *,
+    abort_on_error: bool = False,
+    extra_hint: str | None = None,
+) -> bool:
+    """Test connectivity and report results.
+
+    Returns True on success, False on handled failures. Raises click.Abort when
+    abort_on_error is True and a fatal error occurs.
+    """
+    console.print("\n🔌 Testing connection...")
+    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:
+            agents = client.list_agents()
+            console.print(Text(f"✅ Connection successful! Found {len(agents)} agents", style=SUCCESS_STYLE))
+            return True
+        except Exception as exc:  # pragma: no cover - API failures depend on network
+            console.print(Text(f"⚠️  Connection established but API call failed: {exc}", style=WARNING_STYLE))
+            console.print("   You may need to check your API permissions or network access")
+            if extra_hint:
+                console.print(extra_hint)
+            if abort_on_error:
+                raise click.Abort() from exc
+            return False
+    except Exception as exc:
+        console.print(Text(f"❌ Connection failed: {exc}"))
+        console.print("   Please check your API URL and key")
+        if extra_hint:
+            console.print(extra_hint)
+        if abort_on_error:
+            raise click.Abort() from exc
+        return False
+    finally:
+        if client is not None:
+            client.close()

glaip_sdk/cli/commands/configure.py

@@ -10,43 +10,53 @@ import click
 from rich.console import Console
 from rich.text import Text
 
-from glaip_sdk import Client
-from glaip_sdk.branding import (
-    ACCENT_STYLE,
-    ERROR_STYLE,
-    INFO,
-    PRIMARY,
-    SUCCESS,
-    SUCCESS_STYLE,
-    WARNING_STYLE,
-    AIPBranding,
-)
+from glaip_sdk.branding import ACCENT_STYLE, ERROR_STYLE, INFO, SUCCESS, SUCCESS_STYLE, WARNING_STYLE
+from glaip_sdk.cli.account_store import get_account_store
+from glaip_sdk.cli.commands.common_config import check_connection, render_branding_header
 from glaip_sdk.cli.config import CONFIG_FILE, load_config, save_config
-from glaip_sdk.cli.rich_helpers import markup_text
 from glaip_sdk.cli.hints import format_command_hint
-from glaip_sdk.cli.utils import command_hint, sdk_version
+from glaip_sdk.cli.masking import mask_api_key_display
+from glaip_sdk.cli.rich_helpers import markup_text
+from glaip_sdk.cli.utils import command_hint
 from glaip_sdk.icons import ICON_TOOL
 from glaip_sdk.rich_components import AIPTable
 
 console = Console()
 
+# Shared deprecation banner for legacy config commands
+CONFIG_DEPRECATION_MSG = (
+    f"[{WARNING_STYLE}]Deprecated: 'aip config ...' will be removed in a future release. "
+    "Use 'aip accounts ...' (list/add/use/remove) or 'aip configure' for the wizard.[/]"
+)
+
+
+def _print_config_deprecation() -> None:
+    """Print a standardized deprecation warning for legacy config commands."""
+    console.print(CONFIG_DEPRECATION_MSG)
+
 
 @click.group()
 def config_group() -> None:
     """Configuration management operations."""
-    pass
+    _print_config_deprecation()
 
 
 @config_group.command("list")
-def list_config() -> None:
-    """List current configuration."""
-    config = load_config()
+@click.option("--json", "output_json", is_flag=True, help="Output in JSON format")
+@click.pass_context
+def list_config(ctx: click.Context, output_json: bool) -> None:
+    """List current configuration.
 
-    if not config:
-        _print_missing_config_hint()
-        return
+    Deprecated: run 'aip accounts list' for profile-aware output.
+    """
+    console.print(f"[{WARNING_STYLE}]Deprecated: run 'aip accounts list' for profile-aware output.[/]")
+
+    # Delegate to accounts list by invoking the command
+    from glaip_sdk.cli.commands.accounts import accounts_group  # noqa: PLC0415
 
-    _render_config_table(config)
+    list_cmd = accounts_group.get_command(ctx, "list")
+    if list_cmd:
+        ctx.invoke(list_cmd, output_json=output_json)
 
 
 CONFIG_VALUE_TYPES: dict[str, str] = {
@@ -104,14 +114,49 @@ def _coerce_config_value(key: str, raw_value: str) -> str | bool | int | float:
 @config_group.command("set")
 @click.argument("key")
 @click.argument("value")
-def set_config(key: str, value: str) -> None:
-    """Set a configuration value."""
-    valid_keys = tuple(CONFIG_VALUE_TYPES.keys())
+@click.option(
+    "--account",
+    "account_name",
+    help="Account name to set value for (defaults to active account)",
+)
+def set_config(key: str, value: str, account_name: str | None) -> None:
+    """Set a configuration value.
 
+    For api_url and api_key, this operates on the specified account (or active account).
+    Other keys (timeout, history_default_limit) are global settings.
+    """
+    # For other keys, use legacy config
+    valid_keys = tuple(CONFIG_VALUE_TYPES.keys())
     if key not in valid_keys:
         console.print(f"[{ERROR_STYLE}]Error: Invalid key '{key}'. Valid keys are: {', '.join(valid_keys)}[/]")
         raise click.ClickException(f"Invalid configuration key: {key}")
 
+    store = get_account_store()
+    # For api_url and api_key, update account profile but also mirror to legacy config
+    if key in ("api_url", "api_key"):
+        target_account = account_name or store.get_active_account() or "default"
+        try:
+            account = store.get_account(target_account) or {}
+            account[key] = value
+            store.add_account(
+                target_account,
+                account.get("api_url", ""),
+                account.get("api_key", ""),
+                overwrite=True,
+            )
+        except Exception:
+            # If account store persistence fails (e.g., mocked I/O), continue with legacy config
+            pass
+
+        # Always update legacy config for backward compatibility and test isolation
+        legacy_config = load_config()
+        legacy_config[key] = value
+        save_config(legacy_config)
+
+        display_value = _mask_api_key(value) if key == "api_key" else value
+        console.print(Text(f"✅ Set {key} = {display_value} for account '{target_account}'", style=SUCCESS_STYLE))
+        return
+
     coerced_value = _coerce_config_value(key, value)
     config = load_config()
     config[key] = coerced_value
@@ -127,12 +172,19 @@ def get_config(key: str) -> None:
     """Get a configuration value."""
     config = load_config()
 
-    if key not in config:
+    value = config.get(key)
+
+    # Fallback to account store for api_url/api_key when legacy config lacks the key
+    if value is None and key in {"api_url", "api_key"}:
+        store = get_account_store()
+        active = store.get_active_account() or "default"
+        account = store.get_account(active) or {}
+        value = account.get(key)
+
+    if value is None:
         console.print(markup_text(f"[{WARNING_STYLE}]Configuration key '{key}' not found.[/]"))
         raise click.ClickException(f"Configuration key not found: {key}")
 
-    value = config[key]
-
     if key == "api_key":
         console.print(_mask_api_key(value))
     else:
@@ -190,41 +242,73 @@ def reset_config(force: bool) -> None:
     console.print(message)
 
 
-def _configure_interactive() -> None:
+def _configure_interactive(account_name: str | None = None) -> None:
     """Shared configuration logic for both configure commands."""
+    store = get_account_store()
+
+    # Determine account name (use provided, active, or default)
+    if not account_name:
+        account_name = store.get_active_account() or "default"
+
+    # Get existing account if it exists
+    existing = store.get_account(account_name)
+
     _render_configuration_header()
-    config = load_config()
-    _prompt_configuration_inputs(config)
-    _save_configuration(config)
-    _test_and_report_connection(config)
+    config = _prompt_configuration_inputs_for_account(existing)
+
+    # Save to account store
+    api_url = config.get("api_url", "")
+    api_key = config.get("api_key", "")
+    if api_url and api_key:
+        store.add_account(account_name, api_url, api_key, overwrite=True)
+        console.print(Text(f"\n✅ Configuration saved to account '{account_name}'", style=SUCCESS_STYLE))
+
+    _test_and_report_connection_for_account(account_name)
     _print_post_configuration_hints()
+    # Show active account footer
+    from glaip_sdk.cli.commands.accounts import _print_active_account_footer  # noqa: PLC0415
+
+    _print_active_account_footer(store)
 
 
 @config_group.command()
-def configure() -> None:
-    """Configure AIP CLI credentials and settings interactively."""
-    _configure_interactive()
+@click.option(
+    "--account",
+    "account_name",
+    help="Account name to configure (defaults to active account)",
+)
+def configure(account_name: str | None) -> None:
+    """Configure AIP CLI credentials and settings interactively.
+
+    This command is an alias for 'aip accounts add <name>' and will
+    configure the specified account (or active account if not specified).
+    """
+    _configure_interactive(account_name)
 
 
 # Alias command for backward compatibility
 @click.command()
-def configure_command() -> None:
+@click.option(
+    "--account",
+    "account_name",
+    help="Account name to configure (defaults to active account)",
+)
+def configure_command(account_name: str | None) -> None:
     """Configure AIP CLI credentials and settings interactively.
 
     This is an alias for 'aip config configure' for backward compatibility.
+    For multi-account support, use 'aip accounts add <name>' instead.
     """
+    console.print(
+        f"[{WARNING_STYLE}]Setup tip:[/] Prefer 'aip accounts add <name>' or 'aip configure' from your terminal for "
+        "multi-account setup. Launching the interactive wizard now..."
+    )
     # Delegate to the shared function
-    _configure_interactive()
+    _configure_interactive(account_name)
 
 
 # Note: The config command group should be registered in main.py
-
-
-def _mask_api_key(value: str | None) -> str:
-    """Return a redacted API key string suitable for display."""
-    if not value:
-        return ""
-    return "***" + value[-4:] if len(value) > 4 else "***"
+_mask_api_key = mask_api_key_display
 
 
 def _print_missing_config_hint() -> None:
@@ -251,23 +335,23 @@ def _render_config_table(config: dict[str, str]) -> None:
 
 def _render_configuration_header() -> None:
     """Display the interactive configuration heading/banner."""
-    branding = AIPBranding.create_from_sdk(sdk_version=sdk_version(), package_name="glaip-sdk")
-    heading = "[bold]>_ GDP Labs AI Agents Package (AIP CLI)[/bold]"
-    console.print(heading)
-    console.print()
-    console.print(branding.get_welcome_banner())
-    console.rule("[bold]AIP Configuration[/bold]", style=PRIMARY)
+    render_branding_header(console, "[bold]AIP Configuration[/bold]")
 
 
-def _prompt_configuration_inputs(config: dict[str, str]) -> None:
-    """Interactively prompt for configuration values."""
+def _prompt_configuration_inputs_for_account(existing: dict[str, str] | None) -> dict[str, str]:
+    """Interactively prompt for account configuration values."""
     console.print("\n[bold]Enter your AIP configuration:[/bold]")
-    console.print("(Leave blank to keep current values)")
+    if existing:
+        console.print("(Leave blank to keep current values)")
     console.print("─" * 50)
 
+    config = existing.copy() if existing else {}
+
     _prompt_api_url(config)
     _prompt_api_key(config)
 
+    return config
+
 
 def _prompt_api_url(config: dict[str, str]) -> None:
     """Ask the user for the API URL, preserving existing values by default."""
@@ -291,43 +375,24 @@ def _prompt_api_key(config: dict[str, str]) -> None:
         config["api_key"] = new_key
 
 
-def _save_configuration(config: dict[str, str]) -> None:
-    """Persist the collected configuration to disk."""
-    save_config(config)
-    console.print(Text(f"\n✅ Configuration saved to: {CONFIG_FILE}", style=SUCCESS_STYLE))
+def _test_and_report_connection_for_account(account_name: str) -> None:
+    """Sanity-check the provided credentials against the backend."""
+    store = get_account_store()
+    account = store.get_account(account_name)
+    if not account:
+        return
 
+    api_url = account.get("api_url", "")
+    api_key = account.get("api_key", "")
+    if not api_url or not api_key:
+        return
 
-def _test_and_report_connection(config: dict[str, str]) -> None:
-    """Sanity-check the provided credentials against the backend."""
-    console.print("\n🔌 Testing connection...")
-    client: Client | None = None
-    try:
-        client = Client(api_url=config["api_url"], api_key=config["api_key"])
-        try:
-            agents = client.list_agents()
-            console.print(
-                Text(
-                    f"✅ Connection successful! Found {len(agents)} agents",
-                    style=SUCCESS_STYLE,
-                )
-            )
-        except Exception as exc:  # pragma: no cover - API failures depend on network
-            console.print(
-                Text(
-                    f"⚠️  Connection established but API call failed: {exc}",
-                    style=WARNING_STYLE,
-                )
-            )
-            console.print("   You may need to check your API permissions or network access")
-    except Exception as exc:
-        console.print(Text(f"❌ Connection failed: {exc}"))
-        console.print("   Please check your API URL and key")
-        hint_status = command_hint("status", slash_command="status")
-        if hint_status:
-            console.print(f"   You can run {format_command_hint(hint_status) or hint_status} later to test again")
-    finally:
-        if client is not None:
-            client.close()
+    hint_status = command_hint("status", slash_command="status")
+    extra_hint = None
+    if hint_status:
+        extra_hint = f"   You can run {format_command_hint(hint_status) or hint_status} later to test again"
+
+    check_connection(api_url, api_key, console, abort_on_error=False, extra_hint=extra_hint)
 
 
 def _print_post_configuration_hints() -> None:

glaip_sdk/cli/commands/transcripts.py

@@ -36,8 +36,8 @@ from glaip_sdk.cli.transcript.history import (
 from glaip_sdk.cli.transcript.viewer import ViewerContext, run_viewer_session
 from glaip_sdk.cli.utils import format_size, get_ctx_value, parse_json_line
 from glaip_sdk.rich_components import AIPTable
-from glaip_sdk.utils.rendering.renderer.debug import render_debug_event
 from glaip_sdk.utils.rendering.layout.panels import create_final_panel
+from glaip_sdk.utils.rendering.renderer.debug import render_debug_event
 
 console = Console()
 

glaip_sdk/cli/config.py

@@ -5,12 +5,25 @@ Authors:
 """
 
 import os
+from copy import deepcopy
 from pathlib import Path
 from typing import Any
 
 import yaml
 
-CONFIG_DIR = Path.home() / ".aip"
+_ENV_CONFIG_DIR = os.getenv("AIP_CONFIG_DIR")
+_TEST_ENV = os.getenv("PYTEST_CURRENT_TEST") or os.getenv("PYTEST_XDIST_WORKER")
+
+if _ENV_CONFIG_DIR:
+    CONFIG_DIR = Path(_ENV_CONFIG_DIR)
+elif _TEST_ENV:
+    # Isolate test runs (including xdist workers) from the real user config directory
+    import tempfile
+
+    CONFIG_DIR = Path(tempfile.gettempdir()) / "aip-test-config"
+else:  # pragma: no cover - default path used outside test runs
+    CONFIG_DIR = Path.home() / ".aip"
+
 CONFIG_FILE = CONFIG_DIR / "config.yaml"
 _ALLOWED_KEYS = {
     "api_url",
@@ -18,13 +31,28 @@ _ALLOWED_KEYS = {
     "timeout",
     "history_default_limit",
 }
+# Keys that must be preserved for multi-account support
+_PRESERVE_KEYS = {
+    "version",
+    "active_account",
+    "accounts",
+}
 
 
 def _sanitize_config(data: dict[str, Any] | None) -> dict[str, Any]:
-    """Return config filtered to allowed keys only."""
+    """Return config filtered to allowed keys only, preserving multi-account keys."""
     if not data:
         return {}
-    return {k: v for k, v in data.items() if k in _ALLOWED_KEYS}
+    result: dict[str, Any] = {}
+    # Preserve multi-account structure (defensively copy to avoid callers mutating source)
+    for key in _PRESERVE_KEYS:
+        if key in data:
+            result[key] = deepcopy(data[key])
+    # Add allowed legacy keys (copied to avoid side effects)
+    for key in _ALLOWED_KEYS:
+        if key in data:
+            result[key] = deepcopy(data[key])
+    return result
 
 
 def load_config() -> dict[str, Any]:

glaip_sdk/cli/display.py

@@ -16,8 +16,8 @@ from rich.panel import Panel
 from rich.text import Text
 
 from glaip_sdk.branding import ERROR_STYLE, SUCCESS, SUCCESS_STYLE, WARNING_STYLE
-from glaip_sdk.cli.rich_helpers import markup_text
 from glaip_sdk.cli.hints import command_hint, format_command_hint, in_slash_mode
+from glaip_sdk.cli.rich_helpers import markup_text
 from glaip_sdk.icons import ICON_AGENT, ICON_TOOL
 from glaip_sdk.rich_components import AIPPanel
 

glaip_sdk/cli/hints.py

@@ -6,7 +6,6 @@ Authors:
 
 from __future__ import annotations
 
-
 import click
 
 from glaip_sdk.branding import HINT_COMMAND_STYLE, HINT_DESCRIPTION_COLOR