glaip-sdk 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

glaip_sdk/cli/commands/mcps.py

@@ -2,6 +2,7 @@
 
 Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
 """
 
 import json
@@ -12,6 +13,13 @@ from typing import Any
 import click
 from rich.console import Console
 
+from glaip_sdk.branding import (
+    ACCENT_STYLE,
+    INFO,
+    SUCCESS,
+    SUCCESS_STYLE,
+    WARNING_STYLE,
+)
 from glaip_sdk.cli.context import detect_export_format, get_ctx_value, output_flags
 from glaip_sdk.cli.display import (
     display_api_error,
@@ -43,6 +51,7 @@ from glaip_sdk.cli.utils import (
 from glaip_sdk.config.constants import (
     DEFAULT_MCP_TYPE,
 )
+from glaip_sdk.icons import ICON_TOOL
 from glaip_sdk.rich_components import AIPPanel
 from glaip_sdk.utils import format_datetime
 from glaip_sdk.utils.import_export import convert_export_to_import_format
@@ -54,6 +63,241 @@ from glaip_sdk.utils.serialization import (
 console = Console()
 
 
+def _is_sensitive_data(val: Any) -> bool:
+    """Check if value contains sensitive authentication data.
+
+    Args:
+        val: Value to check for sensitive information
+
+    Returns:
+        True if the value appears to contain sensitive data
+    """
+    if not isinstance(val, dict):
+        return False
+
+    sensitive_patterns = {"token", "password", "secret", "key", "credential"}
+    return any(
+        pattern in str(k).lower() for k in val.keys() for pattern in sensitive_patterns
+    )
+
+
+def _redact_sensitive_dict(val: dict[str, Any]) -> dict[str, Any]:
+    """Redact sensitive fields from a dictionary.
+
+    Args:
+        val: Dictionary to redact
+
+    Returns:
+        Redacted dictionary
+    """
+    redacted = val.copy()
+    sensitive_patterns = {"token", "password", "secret", "key", "credential"}
+    for k in redacted.keys():
+        if any(pattern in k.lower() for pattern in sensitive_patterns):
+            redacted[k] = "<REDACTED>"
+    return redacted
+
+
+def _format_dict_value(val: dict[str, Any]) -> str:
+    """Format a dictionary value for display.
+
+    Args:
+        val: Dictionary to format
+
+    Returns:
+        Formatted string representation
+    """
+    if _is_sensitive_data(val):
+        redacted = _redact_sensitive_dict(val)
+        return json.dumps(redacted, indent=2)
+    return json.dumps(val, indent=2)
+
+
+def _format_preview_value(val: Any) -> str:
+    """Format a value for display in update preview with sensitive data redaction.
+
+    Args:
+        val: Value to format
+
+    Returns:
+        Formatted string representation of the value
+    """
+    if val is None:
+        return "[dim]None[/dim]"
+    if isinstance(val, dict):
+        return _format_dict_value(val)
+    if isinstance(val, str):
+        return f'"{val}"' if val else '""'
+    return str(val)
+
+
+def _build_empty_override_warnings(empty_fields: list[str]) -> list[str]:
+    """Build warning lines for empty CLI overrides.
+
+    Args:
+        empty_fields: List of field names with empty string overrides
+
+    Returns:
+        List of formatted warning lines
+    """
+    if not empty_fields:
+        return []
+
+    warnings = [
+        "\n[yellow]⚠️  Warning: Empty values provided via CLI will override import values[/yellow]"
+    ]
+    warnings.extend(
+        f"- [yellow]{field}: will be set to empty string[/yellow]"
+        for field in empty_fields
+    )
+    return warnings
+
+
+def _validate_import_payload_fields(import_payload: dict[str, Any]) -> bool:
+    """Validate that import payload contains updatable fields.
+
+    Args:
+        import_payload: Import payload to validate
+
+    Returns:
+        True if payload has updatable fields, False otherwise
+    """
+    updatable_fields = {"name", "transport", "description", "config", "authentication"}
+    has_updatable = any(field in import_payload for field in updatable_fields)
+
+    if not has_updatable:
+        available_fields = set(import_payload.keys())
+        print_markup(
+            "[yellow]⚠️  No updatable fields found in import file.[/yellow]\n"
+            f"[dim]Found fields: {', '.join(sorted(available_fields))}[/dim]\n"
+            f"[dim]Updatable fields: {', '.join(sorted(updatable_fields))}[/dim]"
+        )
+    return has_updatable
+
+
+def _get_config_transport(
+    transport: str | None,
+    import_payload: dict[str, Any] | None,
+    mcp: Any,
+) -> str | None:
+    """Get the transport value for config validation.
+
+    Args:
+        transport: CLI transport flag
+        import_payload: Optional import payload
+        mcp: Current MCP object
+
+    Returns:
+        Transport value or None
+    """
+    if import_payload:
+        return transport or import_payload.get("transport")
+    return transport or getattr(mcp, "transport", None)
+
+
+def _build_update_data_from_sources(
+    import_payload: dict[str, Any] | None,
+    mcp: Any,
+    name: str | None,
+    transport: str | None,
+    description: str | None,
+    config: str | None,
+    auth: str | None,
+) -> dict[str, Any]:
+    """Build update data from import payload and CLI flags.
+
+    Args:
+        import_payload: Optional import payload
+        mcp: Current MCP object
+        name: CLI name flag
+        transport: CLI transport flag
+        description: CLI description flag
+        config: CLI config flag
+        auth: CLI auth flag
+
+    Returns:
+        Dictionary with update data
+    """
+    update_data = {}
+
+    # Start with import data if available
+    if import_payload:
+        updatable_fields = [
+            "name",
+            "transport",
+            "description",
+            "config",
+            "authentication",
+        ]
+        for field in updatable_fields:
+            if field in import_payload:
+                update_data[field] = import_payload[field]
+
+    # CLI flags override import values
+    if name is not None:
+        update_data["name"] = name
+    if transport is not None:
+        update_data["transport"] = transport
+    if description is not None:
+        update_data["description"] = description
+    if config is not None:
+        parsed_config = parse_json_input(config)
+        config_transport = _get_config_transport(transport, import_payload, mcp)
+        update_data["config"] = validate_mcp_config_structure(
+            parsed_config,
+            transport=config_transport,
+            source="--config",
+        )
+    if auth is not None:
+        parsed_auth = parse_json_input(auth)
+        update_data["authentication"] = validate_mcp_auth_structure(
+            parsed_auth, source="--auth"
+        )
+
+    return update_data
+
+
+def _collect_cli_overrides(
+    name: str | None,
+    transport: str | None,
+    description: str | None,
+    config: str | None,
+    auth: str | None,
+) -> dict[str, Any]:
+    """Collect CLI flags that were explicitly provided.
+
+    Args:
+        name: CLI name flag
+        transport: CLI transport flag
+        description: CLI description flag
+        config: CLI config flag
+        auth: CLI auth flag
+
+    Returns:
+        Dictionary of provided CLI overrides
+    """
+    cli_overrides = {}
+    if name is not None:
+        cli_overrides["name"] = name
+    if transport is not None:
+        cli_overrides["transport"] = transport
+    if description is not None:
+        cli_overrides["description"] = description
+    if config is not None:
+        cli_overrides["config"] = config
+    if auth is not None:
+        cli_overrides["auth"] = auth
+    return cli_overrides
+
+
+def _handle_cli_error(ctx: Any, error: Exception, operation: str) -> None:
+    """Render CLI error once and exit with non-zero status."""
+    handle_json_output(ctx, error=error)
+    if get_ctx_value(ctx, "view") != "json":
+        display_api_error(error, operation)
+    ctx.exit(1)
+
+
 @click.group(name="mcps", no_args_is_help=True)
 def mcps_group() -> None:
     """MCP management operations.
@@ -291,8 +535,8 @@ def list_mcps(ctx: Any) -> None:
         # Define table columns: (data_key, header, style, width)
         columns = [
             ("id", "ID", "dim", 36),
-            ("name", "Name", "cyan", None),
-            ("config", "Config", "blue", None),
+            ("name", "Name", ACCENT_STYLE, None),
+            ("config", "Config", INFO, None),
         ]
 
         # Transform function for safe dictionary access
@@ -440,10 +684,7 @@ def create(
         handle_rich_output(ctx, rich_panel)
 
     except Exception as e:
-        handle_json_output(ctx, error=e)
-        if get_ctx_value(ctx, "view") != "json":
-            display_api_error(e, "MCP creation")
-        raise click.ClickException(str(e))
+        _handle_cli_error(ctx, e, "MCP creation")
 
 
 def _handle_mcp_export(
@@ -482,11 +723,11 @@ def _handle_mcp_export(
             mcp = client.mcps.get_mcp_by_id(mcp.id)
     except Exception as e:
         print_markup(
-            f"[yellow]⚠️  Could not fetch full MCP details: {e}[/yellow]",
+            f"[{WARNING_STYLE}]⚠️  Could not fetch full MCP details: {e}[/]",
             console=console,
         )
         print_markup(
-            "[yellow]⚠️  Proceeding with available data[/yellow]", console=console
+            f"[{WARNING_STYLE}]⚠️  Proceeding with available data[/]", console=console
         )
 
     # Determine if we should prompt for secrets
@@ -495,8 +736,8 @@ def _handle_mcp_export(
     # Warn user if non-interactive mode forces placeholder usage
     if not no_auth_prompt and not sys.stdin.isatty():
         print_markup(
-            "[yellow]⚠️  Non-interactive mode detected. "
-            "Using placeholder values for secrets.[/yellow]",
+            f"[{WARNING_STYLE}]⚠️  Non-interactive mode detected. "
+            "Using placeholder values for secrets.[/]",
             console=console,
         )
 
@@ -531,8 +772,8 @@ def _handle_mcp_export(
             write_resource_export(export_path, export_payload, detected_format)
 
     print_markup(
-        f"[green]✅ Complete MCP configuration exported to: "
-        f"{export_path} (format: {detected_format})[/green]",
+        f"[{SUCCESS_STYLE}]✅ Complete MCP configuration exported to: "
+        f"{export_path} (format: {detected_format})[/]",
         console=console,
     )
 
@@ -574,7 +815,7 @@ def _display_mcp_details(ctx: Any, client: Any, mcp: Any) -> None:
         )
     else:
         # Fall back to Pydantic model data
-        console.print("[yellow]Falling back to Pydantic model data[/yellow]")
+        console.print(f"[{WARNING_STYLE}]Falling back to Pydantic model data[/]")
         result_data = {
             "id": str(getattr(mcp, "id", "N/A")),
             "name": getattr(mcp, "name", "N/A"),
@@ -680,8 +921,8 @@ def list_tools(ctx: Any, mcp_ref: str) -> None:
 
         # Define table columns: (data_key, header, style, width)
         columns = [
-            ("name", "Name", "cyan", None),
-            ("description", "Description", "green", 50),
+            ("name", "Name", ACCENT_STYLE, None),
+            ("description", "Description", INFO, 50),
         ]
 
         # Transform function for safe dictionary access
@@ -694,7 +935,11 @@ def list_tools(ctx: Any, mcp_ref: str) -> None:
             }
 
         output_list(
-            ctx, tools, f"🔧 Tools from MCP: {mcp.name}", columns, transform_tool
+            ctx,
+            tools,
+            f"{ICON_TOOL} Tools from MCP: {mcp.name}",
+            columns,
+            transform_tool,
         )
 
     except Exception as e:
@@ -734,7 +979,7 @@ def connect(ctx: Any, config_file: str) -> None:
         view = get_ctx_value(ctx, "view", "rich")
         if view != "json":
             print_markup(
-                f"[yellow]Connecting to MCP with config from {config_file}...[/yellow]",
+                f"[{WARNING_STYLE}]Connecting to MCP with config from {config_file}...[/]",
                 console=console,
             )
 
@@ -751,10 +996,10 @@ def connect(ctx: Any, config_file: str) -> None:
             handle_json_output(ctx, result)
         else:
             success_panel = AIPPanel(
-                f"[green]✓[/green] MCP connection successful!\n\n"
+                f"[{SUCCESS_STYLE}]✓[/] MCP connection successful!\n\n"
                 f"[bold]Result:[/bold] {result}",
                 title="🔌 Connection",
-                border_style="green",
+                border_style=SUCCESS,
             )
             console.print(success_panel)
 
@@ -762,9 +1007,50 @@ def connect(ctx: Any, config_file: str) -> None:
         raise click.ClickException(str(e))
 
 
+def _generate_update_preview(
+    mcp: Any, update_data: dict[str, Any], cli_overrides: dict[str, Any]
+) -> str:
+    """Generate formatted preview of changes for user confirmation.
+
+    Args:
+        mcp: Current MCP object
+        update_data: Data that will be sent in update request
+        cli_overrides: CLI flags that were explicitly provided
+
+    Returns:
+        Formatted preview string showing old→new values
+    """
+    lines = [
+        f"\n[bold]The following fields will be updated for MCP '{mcp.name}':[/bold]\n"
+    ]
+
+    empty_overrides = []
+
+    # Show each field that will be updated
+    for field, new_value in update_data.items():
+        old_value = getattr(mcp, field, None)
+
+        # Track empty CLI overrides
+        if field in cli_overrides and cli_overrides[field] == "":
+            empty_overrides.append(field)
+
+        old_display = _format_preview_value(old_value)
+        new_display = _format_preview_value(new_value)
+
+        lines.append(f"- [cyan]{field}[/cyan]: {old_display} → {new_display}")
+
+    # Add warnings for empty CLI overrides
+    lines.extend(_build_empty_override_warnings(empty_overrides))
+
+    return "\n".join(lines)
+
+
 @mcps_group.command()
 @click.argument("mcp_ref")
 @click.option("--name", help="New MCP name")
+@click.option(
+    "--transport", type=click.Choice(["http", "sse"]), help="New transport protocol"
+)
 @click.option("--description", help="New description")
 @click.option(
     "--config",
@@ -776,62 +1062,105 @@ def connect(ctx: Any, config_file: str) -> None:
     "auth",
     help="JSON authentication object or @file reference (e.g., @auth.json)",
 )
+@click.option(
+    "--import",
+    "import_file",
+    type=click.Path(exists=True, dir_okay=False, readable=True),
+    help="Import MCP configuration from JSON or YAML export",
+)
+@click.option("-y", is_flag=True, help="Skip confirmation prompt when using --import")
 @output_flags()
 @click.pass_context
 def update(
     ctx: Any,
     mcp_ref: str,
     name: str | None,
+    transport: str | None,
     description: str | None,
     config: str | None,
     auth: str | None,
+    import_file: str | None,
+    y: bool,
 ) -> None:
     """Update an existing MCP with new configuration values.
 
+    You can update an MCP by providing individual fields via CLI options, or by
+    importing from a file and optionally overriding specific fields.
+
     Args:
         ctx: Click context containing output format preferences
         mcp_ref: MCP reference (ID or name)
         name: New MCP name (optional)
+        transport: New transport protocol (optional)
         description: New description (optional)
         config: New JSON configuration string or @file reference (optional)
         auth: New JSON authentication object or @file reference (optional)
+        import_file: Optional path to import configuration from export file.
+            CLI options override imported values.
+        y: Skip confirmation prompt when using --import
 
     Raises:
         ClickException: If MCP not found, JSON invalid, or no fields specified
 
     Note:
-        At least one field must be specified for update.
-        Uses PUT for complete updates or PATCH for partial updates.
+        Must specify either --import OR at least one CLI field.
+        CLI options override imported values when both are specified.
+        Uses PATCH for import-based updates, PUT/PATCH for CLI-only updates.
+
+    Examples:
+        Update with CLI options:
+            aip mcps update my-mcp --name new-name --transport sse
+
+        Import from file:
+            aip mcps update my-mcp --import mcp-export.json
+
+        Import with overrides:
+            aip mcps update my-mcp --import mcp-export.json --name new-name -y
     """
     try:
         client = get_client(ctx)
 
+        # Validate that at least one update method is provided
+        cli_flags_provided = any(
+            v is not None for v in [name, transport, description, config, auth]
+        )
+        if not import_file and not cli_flags_provided:
+            raise click.ClickException(
+                "No update fields specified. Use --import file or at least one of: "
+                "--name, --transport, --description, --config, --auth"
+            )
+
         # Resolve MCP using helper function
         mcp = _resolve_mcp(ctx, client, mcp_ref)
 
-        # Build update data
-        update_data = {}
-        if name is not None:
-            update_data["name"] = name
-        if description is not None:
-            update_data["description"] = description
-        if config is not None:
-            parsed_config = parse_json_input(config)
-            update_data["config"] = validate_mcp_config_structure(
-                parsed_config,
-                transport=getattr(mcp, "transport", None),
-                source="--config",
-            )
-        if auth is not None:
-            parsed_auth = parse_json_input(auth)
-            update_data["authentication"] = validate_mcp_auth_structure(
-                parsed_auth, source="--auth"
-            )
+        # Load and validate import data if provided
+        import_payload = None
+        if import_file:
+            import_payload = _load_import_ready_payload(import_file)
+            if not _validate_import_payload_fields(import_payload):
+                return
+
+        # Build update data from import and CLI flags
+        update_data = _build_update_data_from_sources(
+            import_payload, mcp, name, transport, description, config, auth
+        )
 
         if not update_data:
             raise click.ClickException("No update fields specified")
 
-        # Update MCP (automatically chooses PUT or PATCH based on provided fields)
+        # Show confirmation preview for import-based updates (unless -y flag)
+        if import_payload and not y:
+            cli_overrides = _collect_cli_overrides(
+                name, transport, description, config, auth
+            )
+            preview = _generate_update_preview(mcp, update_data, cli_overrides)
+            print_markup(preview)
+
+            if not click.confirm("\nContinue with update?", default=False):
+                print_markup("[yellow]Update cancelled.[/yellow]")
+                return
+
+        # Update MCP
         with spinner_context(
             ctx,
             "[bold blue]Updating MCP…[/bold blue]",
@@ -843,10 +1172,7 @@ def update(
         handle_rich_output(ctx, display_update_success("MCP", updated_mcp.name))
 
     except Exception as e:
-        handle_json_output(ctx, error=e)
-        if get_ctx_value(ctx, "view") != "json":
-            display_api_error(e, "MCP update")
-        raise click.ClickException(str(e))
+        _handle_cli_error(ctx, e, "MCP update")
 
 
 @mcps_group.command()
@@ -896,7 +1222,4 @@ def delete(ctx: Any, mcp_ref: str, yes: bool) -> None:
         handle_rich_output(ctx, display_deletion_success("MCP", mcp.name))
 
     except Exception as e:
-        handle_json_output(ctx, error=e)
-        if get_ctx_value(ctx, "view") != "json":
-            display_api_error(e, "MCP deletion")
-        raise click.ClickException(str(e))
+        _handle_cli_error(ctx, e, "MCP deletion")

glaip_sdk/cli/commands/models.py

@@ -9,6 +9,7 @@ from typing import Any
 import click
 from rich.console import Console
 
+from glaip_sdk.branding import ACCENT_STYLE, INFO, SUCCESS
 from glaip_sdk.cli.context import output_flags
 from glaip_sdk.cli.utils import (
     get_client,
@@ -42,9 +43,9 @@ def list_models(ctx: Any) -> None:
         # Define table columns: (data_key, header, style, width)
         columns = [
             ("id", "ID", "dim", 36),
-            ("provider", "Provider", "cyan", None),
-            ("name", "Model", "green", None),
-            ("base_url", "Base URL", "yellow", None),
+            ("provider", "Provider", ACCENT_STYLE, None),
+            ("name", "Model", SUCCESS, None),
+            ("base_url", "Base URL", INFO, None),
         ]
 
         # Transform function for safe dictionary access