htcli 1.1.0__py3-none-any.whl

src/htcli/commands/config/handlers.py

@@ -0,0 +1,347 @@
+"""
+Config command handlers.
+
+Business logic for configuration operations following the 3-step pattern.
+"""
+
+from typing import Optional
+
+import typer
+
+from ...client.offchain.config import (
+    get_config_path,
+    get_config_value,
+    initialize_config,
+    load_config,
+    set_config_value,
+    validate_config,
+)
+
+# Temporary imports from utils layer until client layer is complete
+# from ...utils.config import (
+#     initialize_config,
+#     load_config,
+#     save_config,
+#     validate_config,
+#     set_config_value,
+#     get_config_value,
+#     get_config_path,
+# )
+from ...errors.base import HTCLIError
+from ...errors.handlers import handle_and_display_error
+from ...models.requests import (
+    ConfigPathRequest,
+    ConfigShowRequest,
+    ConfigValidateRequest,
+)
+from ...models.responses import (
+    ConfigGetResponse,
+    ConfigInitResponse,
+    ConfigPathResponse,
+    ConfigSetResponse,
+    ConfigShowResponse,
+    ConfigValidateResponse,
+)
+from .display import (
+    display_config_get_result,
+    display_config_init_result,
+    display_config_path_result,
+    display_config_set_result,
+    display_config_show_result,
+    display_config_validate_result,
+)
+from .prompts import (
+    _is_interactive,
+    confirm_config_overwrite,
+    prompt_config_get,
+    prompt_config_init,
+    prompt_config_set,
+)
+
+
+def init_handler(
+    config_file: Optional[str] = None,
+    force: bool = False,
+    endpoint: Optional[str] = None,
+    ws_endpoint: Optional[str] = None,
+    timeout: Optional[int] = None,
+    retry_attempts: Optional[int] = None,
+    output_format: Optional[str] = None,
+    verbose: Optional[bool] = None,
+    color: Optional[bool] = None,
+    wallet_path: Optional[str] = None,
+    default_wallet: Optional[str] = None,
+    encryption_enabled: Optional[bool] = None,
+) -> None:
+    """Handle configuration initialization."""
+    try:
+        # Get configuration path
+        config_path = get_config_path(config_file)
+
+        # Check if config exists and force flag
+        if config_path.exists() and not force:
+            if not confirm_config_overwrite(config_path):
+                return
+
+        # Prompt for configuration parameters (only missing ones)
+        request = prompt_config_init(
+            config_file=config_file,
+            force=force,
+            endpoint=endpoint,
+            ws_endpoint=ws_endpoint,
+            timeout=timeout,
+            retry_attempts=retry_attempts,
+            output_format=output_format,
+            verbose=verbose,
+            color=color,
+            wallet_path=wallet_path,
+            default_wallet=default_wallet,
+            encryption_enabled=encryption_enabled,
+        )
+
+        # Initialize configuration
+        result = initialize_config(request)
+
+        # Create response
+        response = ConfigInitResponse(
+            config_path=str(result["config_path"]),
+            created=result["created"],
+            message=result["message"],
+        )
+
+        # Display result
+        display_config_init_result(response)
+
+    except Exception as e:
+        handle_and_display_error(e, "Configuration initialization failed")
+
+
+def show_handler(
+    config_file: Optional[str] = None,
+    format_type: str = "table",
+) -> None:
+    """Handle configuration display."""
+    try:
+        # Create request
+        request = ConfigShowRequest(
+            config_file=config_file,
+            format_type=format_type,
+        )
+
+        # Load configuration
+        result = load_config(request)
+
+        # Create response
+        response = ConfigShowResponse(
+            config_path=str(result["config_path"]),
+            config_data=result["config_data"],
+            exists=result["exists"],
+        )
+
+        # Display result
+        display_config_show_result(response, format_type)
+
+    except Exception as e:
+        handle_and_display_error(e, "Failed to show configuration")
+
+
+def set_handler(
+    key: Optional[str] = None,
+    value: Optional[str] = None,
+    config_file: Optional[str] = None,
+) -> None:
+    """Handle configuration value setting."""
+    try:
+        if not _is_interactive():
+            if not key:
+                raise HTCLIError(
+                    "Missing option '--key'. Provide --key in non-interactive mode."
+                )
+            if not value:
+                raise HTCLIError(
+                    "Missing option '--value'. Provide --value in non-interactive mode."
+                )
+
+        # Prompt for parameters
+        request = prompt_config_set(key=key, value=value, config_file=config_file)
+
+        # Set configuration value
+        result = set_config_value(request)
+
+        # Check if value is unchanged (early exit)
+        if result.get("unchanged", False):
+            from ...ui.display import print_info
+            print_info(
+                f"Configuration key '{result['key']}' is already set to '{result['new_value']}'. No change needed.",
+                emoji=True,
+            )
+            return
+
+        # Create response
+        response = ConfigSetResponse(
+            config_path=str(result["config_path"]),
+            key=result["key"],
+            old_value=result["old_value"],
+            new_value=result["new_value"],
+            message=result["message"],
+        )
+
+        # Display result
+        display_config_set_result(response)
+
+    except (KeyboardInterrupt, typer.Abort):
+        # Re-raise cancellation exceptions to properly exit
+        raise
+    except Exception as e:
+        handle_and_display_error(e, "Failed to set configuration value")
+
+
+def get_handler(
+    key: Optional[str] = None,
+    config_file: Optional[str] = None,
+) -> None:
+    """Handle configuration value retrieval."""
+    try:
+        if not _is_interactive() and not key:
+            raise HTCLIError(
+                "Missing option '--key'. Provide --key in non-interactive mode."
+            )
+
+        # Prompt for parameters
+        request = prompt_config_get(key=key, config_file=config_file)
+
+        # Get configuration value
+        result = get_config_value(request)
+
+        # Create response
+        response = ConfigGetResponse(
+            key=result["key"],
+            value=result["value"],
+            value_type=result["value_type"],
+        )
+
+        # Display result
+        display_config_get_result(response)
+
+    except Exception as e:
+        handle_and_display_error(e, "Failed to get configuration value")
+
+
+def validate_handler(
+    config_file: Optional[str] = None,
+) -> None:
+    """Handle configuration validation."""
+    try:
+        # Create request
+        request = ConfigValidateRequest(
+            config_file=config_file,
+        )
+
+        # Validate configuration
+        result = validate_config(request)
+
+        # Create response
+        response = ConfigValidateResponse(
+            config_path=str(result["config_path"]),
+            valid=result["valid"],
+            errors=result.get("errors", []),
+            message=result["message"],
+        )
+
+        # Display result
+        display_config_validate_result(response)
+
+    except Exception as e:
+        handle_and_display_error(e, "Configuration validation failed")
+
+
+def path_handler(
+    config_file: Optional[str] = None,
+) -> None:
+    """Handle configuration path display."""
+    try:
+        # Create request
+        request = ConfigPathRequest(
+            config_file=config_file,
+        )
+
+        # Get configuration path
+        config_path = get_config_path(request.config_file)
+
+        # Create response
+        response = ConfigPathResponse(
+            config_path=str(config_path),
+            exists=config_path.exists(),
+            absolute_path=str(config_path.absolute()),
+        )
+
+        # Display result
+        display_config_path_result(response)
+
+    except Exception as e:
+        handle_and_display_error(e, "Failed to get configuration path")
+
+
+def edit_handler(
+    config_file: Optional[str] = None,
+) -> None:
+    """Handle configuration editing."""
+    try:
+        # Get configuration path
+        config_path = get_config_path(config_file)
+
+        # Check if config exists
+        if not config_path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        # Load existing configuration for editing
+        load_request = ConfigShowRequest(
+            config_file=config_file,
+            format_type="yaml",
+        )
+        load_config(load_request)
+
+        # Prompt for new configuration based on existing
+        request = prompt_config_init(
+            config_file=config_file,
+            force=True,  # Editing always overwrites
+        )
+
+        # Save updated configuration
+        result = initialize_config(request)
+
+        # Create response
+        response = ConfigInitResponse(
+            config_path=str(result["config_path"]),
+            created=False,  # Editing, not creating
+            message="Configuration updated successfully",
+        )
+
+        # Display result
+        display_config_init_result(response)
+
+    except Exception as e:
+        handle_and_display_error(e, "Configuration editing failed")
+
+
+# Legacy aliases retained for older tests and callers.
+def set_config_handler(
+    key: Optional[str] = None,
+    value: Optional[str] = None,
+    config_file: Optional[str] = None,
+) -> None:
+    set_handler(key=key, value=value, config_file=config_file)
+
+
+def get_config_handler(
+    key: Optional[str] = None,
+    config_file: Optional[str] = None,
+) -> None:
+    get_handler(key=key, config_file=config_file)
+
+
+def unset_config_handler(
+    key: Optional[str] = None,
+    config_file: Optional[str] = None,
+) -> None:
+    raise NotImplementedError("Config unset is not implemented in this CLI.")

src/htcli/commands/config/prompts.py

@@ -0,0 +1,357 @@
+"""
+Config command prompting logic.
+
+Handles collecting user input for configuration operations using HTCLI UI components.
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+from ...errors.base import HTCLIError
+from rich.prompt import Prompt
+
+from ...models.requests import (
+    ConfigEditRequest,
+    ConfigGetRequest,
+    ConfigInitRequest,
+    ConfigPathRequest,
+    ConfigSetRequest,
+    ConfigShowRequest,
+    ConfigValidateRequest,
+)
+from ...ui.colors import info, warning
+from ...ui.display import HTCLIConsole
+from ...client.offchain.config import ConfigManager
+from ...ui.prompts import (
+    prompt_for_confirmation,
+    prompt_for_optional,
+    prompt_for_required,
+    select_prompt,
+)
+from ...utils.validation import (
+    validate_retry_attempts,
+    validate_rpc_url_prompt,
+    validate_timeout,
+)
+
+console = HTCLIConsole()
+
+
+def _is_interactive() -> bool:
+    """Return whether stdin is interactive at call time."""
+    stdin = getattr(sys, "stdin", None)
+    return bool(stdin and stdin.isatty())
+
+
+def prompt_config_init(
+    config_file: Optional[str] = None,
+    force: bool = False,
+    endpoint: Optional[str] = None,
+    ws_endpoint: Optional[str] = None,
+    timeout: Optional[int] = None,
+    retry_attempts: Optional[int] = None,
+    output_format: Optional[str] = None,
+    verbose: Optional[bool] = None,
+    color: Optional[bool] = None,
+    wallet_path: Optional[str] = None,
+    default_wallet: Optional[str] = None,
+    encryption_enabled: Optional[bool] = None,
+) -> ConfigInitRequest:
+    """Prompt for configuration initialization parameters (only missing ones)."""
+    console.print(info("🔧 Configuration Initialization"))
+    console.print("Setting up your HTCLI configuration...\n")
+
+    # Network configuration
+    console.print(info("Network Configuration:"))
+    endpoint = prompt_for_optional(
+        "RPC Endpoint",
+        param_type=str,
+        default="wss://rpc.htcli.io/",
+        help_text="WebSocket URL for blockchain communication",
+        validator=validate_rpc_url_prompt,
+        provided_value=endpoint,
+    )
+    if endpoint:
+        # If endpoint was provided interactively, use it as default for ws_endpoint
+        if ws_endpoint is None:
+            ws_endpoint = endpoint
+    elif ws_endpoint is None:
+        # If endpoint was provided via switch but ws_endpoint wasn't, use endpoint
+        ws_endpoint = endpoint
+
+    ws_endpoint = prompt_for_optional(
+        "WebSocket Endpoint",
+        param_type=str,
+        default=endpoint or "wss://rpc.htcli.io/",
+        help_text="WebSocket endpoint for real-time communication",
+        validator=validate_rpc_url_prompt,
+        provided_value=ws_endpoint,
+    )
+
+    # Handle timeout - convert to int if string, validate, then prompt if needed
+    timeout_value = timeout
+    if timeout is not None:
+        if isinstance(timeout, str):
+            try:
+                timeout_value = int(timeout)
+            except ValueError:
+                timeout_value = None
+        is_valid, error_msg = validate_timeout(timeout_value)
+        if not is_valid:
+            console.print(warning(f"Invalid timeout: {error_msg}"))
+            timeout_value = 30
+
+    if timeout_value is None and _is_interactive():
+        timeout_str = prompt_for_optional(
+            "Connection timeout (seconds)",
+            param_type=str,
+            default="30",
+            help_text="Timeout for network connections",
+        )
+        try:
+            timeout = int(timeout_str) if timeout_str else 30
+        except ValueError:
+            console.print(warning("Invalid timeout, using default: 30"))
+            timeout = 30
+    elif timeout_value is not None:
+        timeout = timeout_value
+    else:
+        timeout = 30
+
+    # Handle retry_attempts - convert to int if string, validate, then prompt if needed
+    retry_value = retry_attempts
+    if retry_attempts is not None:
+        if isinstance(retry_attempts, str):
+            try:
+                retry_value = int(retry_attempts)
+            except ValueError:
+                retry_value = None
+        is_valid, error_msg = validate_retry_attempts(retry_value)
+        if not is_valid:
+            console.print(warning(f"Invalid retry attempts: {error_msg}"))
+            retry_value = 3
+
+    if retry_value is None and _is_interactive():
+        retry_str = prompt_for_optional(
+            "Retry attempts",
+            param_type=str,
+            default="3",
+            help_text="Number of retry attempts for failed connections",
+        )
+        try:
+            retry_attempts = int(retry_str) if retry_str else 3
+        except ValueError:
+            console.print(warning("Invalid retry attempts, using default: 3"))
+            retry_attempts = 3
+    elif retry_value is not None:
+        retry_attempts = retry_value
+    else:
+        retry_attempts = 3
+
+    # Output configuration
+    if _is_interactive() and (output_format is None or verbose is None or color is None):
+        console.print(info("\nOutput Configuration:"))
+
+        if output_format is None:
+            output_format = Prompt.ask(
+                "Default output format",
+                choices=["table", "json", "csv"],
+                default="table",
+            )
+
+        if verbose is None:
+            verbose = prompt_for_confirmation(
+                "Enable verbose output by default?", default=False
+            )
+
+        if color is None:
+            color = prompt_for_confirmation("Enable colored output?", default=True)
+
+    # Wallet configuration
+    if _is_interactive() and (
+        wallet_path is None or default_wallet is None or encryption_enabled is None
+    ):
+        console.print(info("\nWallet Configuration:"))
+
+        if wallet_path is None:
+            wallet_path = prompt_for_optional(
+                "Wallet storage path",
+                param_type=str,
+                default="~/.htcli/wallets",
+                help_text="Directory where wallets will be stored",
+            )
+
+        if default_wallet is None:
+            default_wallet = prompt_for_optional(
+                "Default wallet name",
+                param_type=str,
+                default="default",
+                help_text="Default wallet to use",
+            )
+
+        if encryption_enabled is None:
+            encryption_enabled = prompt_for_confirmation(
+                "Enable wallet encryption?", default=True
+            )
+
+    # Ensure defaults are set
+    endpoint = endpoint or "wss://rpc.htcli.io/"
+    ws_endpoint = ws_endpoint or endpoint
+    timeout = timeout if timeout is not None else 30
+    retry_attempts = retry_attempts if retry_attempts is not None else 3
+    output_format = output_format or "table"
+    verbose = verbose if verbose is not None else False
+    color = color if color is not None else True
+    wallet_path = wallet_path or "~/.htcli/wallets"
+    default_wallet = default_wallet or "default"
+    encryption_enabled = encryption_enabled if encryption_enabled is not None else True
+
+    return ConfigInitRequest(
+        config_file=config_file,
+        force=force,
+        endpoint=endpoint,
+        ws_endpoint=ws_endpoint,
+        timeout=timeout,
+        retry_attempts=retry_attempts,
+        output_format=output_format,
+        verbose=verbose,
+        color=color,
+        wallet_path=wallet_path,
+        default_wallet=default_wallet,
+        encryption_enabled=encryption_enabled,
+    )
+
+
+def prompt_config_show(
+    config_file: Optional[str] = None,
+    format_type: str = "table",
+) -> ConfigShowRequest:
+    """Prompt for configuration display parameters."""
+    return ConfigShowRequest(
+        config_file=config_file,
+        format_type=format_type,
+    )
+
+
+def _get_config_keys_for_selection(config_file: Optional[str] = None) -> list[str]:
+    """Helper function to get flattened list of config keys for selection."""
+    # Build a list of available configuration keys for selection
+    manager = (
+        ConfigManager(Path(config_file).parent) if config_file else ConfigManager()
+    )
+    if config_file:
+        manager.config_file = Path(config_file).expanduser()
+
+    result = manager.load_config()
+    config_data = result["data"]
+
+    def flatten(prefix: str, data: dict, out: list[str]):
+        for k, v in data.items():
+            path = f"{prefix}.{k}" if prefix else k
+            if isinstance(v, dict):
+                flatten(path, v, out)
+            else:
+                out.append(path)
+
+    keys: list[str] = []
+    flatten("", config_data, keys)
+    keys.sort()
+    return keys
+
+
+def prompt_config_set(
+    key: Optional[str] = None,
+    value: Optional[str] = None,
+    config_file: Optional[str] = None,
+) -> ConfigSetRequest:
+    """Prompt for configuration value setting."""
+    # Validate key if provided (must be non-empty)
+    if key is not None:
+        if not key or not key.strip():
+            console.print(warning("Configuration key cannot be empty"))
+            key = None
+
+    if not key:
+        keys = _get_config_keys_for_selection(config_file)
+        choices = [(k, k, k) for k in keys]
+        console.print(info("Select configuration key to set"))
+        key = select_prompt("Enter number or key", choices)
+
+    # Validate value if provided (must be non-empty)
+    if value is not None:
+        if not value or not value.strip():
+            console.print(warning("Configuration value cannot be empty"))
+            value = None
+
+    if not value:
+        value = prompt_for_required(
+            f"Value for '{key}'", param_type=str, help_text="New value to set", provided_value=value
+        )
+
+    return ConfigSetRequest(
+        config_file=config_file,
+        key=key,
+        value=value,
+    )
+
+
+def prompt_config_get(
+    key: Optional[str] = None,
+    config_file: Optional[str] = None,
+) -> ConfigGetRequest:
+    """Prompt for configuration value retrieval."""
+    # Validate key if provided (must be non-empty)
+    if key is not None:
+        if not key or not key.strip():
+            console.print(warning("Configuration key cannot be empty"))
+            key = None
+
+    if not key:
+        keys = _get_config_keys_for_selection(config_file)
+        choices = [(k, k, k) for k in keys]
+        console.print(info("Select configuration key to get"))
+        key = select_prompt("Enter number or key", choices)
+
+    return ConfigGetRequest(
+        config_file=config_file,
+        key=key,
+    )
+
+
+def prompt_config_validate(
+    config_file: Optional[str] = None,
+) -> ConfigValidateRequest:
+    """Prompt for configuration validation."""
+    return ConfigValidateRequest(
+        config_file=config_file,
+    )
+
+
+def prompt_config_path(
+    config_file: Optional[str] = None,
+) -> ConfigPathRequest:
+    """Prompt for configuration path display."""
+    return ConfigPathRequest(
+        config_file=config_file,
+    )
+
+
+def prompt_config_edit(
+    config_file: Optional[str] = None,
+) -> ConfigEditRequest:
+    """Prompt for configuration editing."""
+    return ConfigEditRequest(
+        config_file=config_file,
+    )
+
+
+def confirm_config_overwrite(config_path: Path) -> bool:
+    """Confirm overwriting existing configuration."""
+    console.print(warning(f"⚠️  Configuration file already exists: {config_path}"))
+    return prompt_for_confirmation("Overwrite existing configuration?", default=False)
+
+
+def confirm_config_changes() -> bool:
+    """Confirm saving configuration changes."""
+    return prompt_for_confirmation("Save configuration changes?", default=True)