glaip-sdk 0.6.25__py3-none-any.whl → 0.6.26__py3-none-any.whl

glaip_sdk/cli/commands/mcps/tools.py

@@ -0,0 +1,235 @@
+"""List MCP tools command.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import click
+
+from glaip_sdk.branding import ACCENT_STYLE, INFO
+from glaip_sdk.cli.context import get_ctx_value, output_flags
+from glaip_sdk.cli.core.context import get_client
+from glaip_sdk.cli.core.output import output_list
+from glaip_sdk.cli.core.rendering import spinner_context
+from glaip_sdk.cli.display import handle_json_output
+from glaip_sdk.cli.io import load_resource_from_file_with_validation
+from glaip_sdk.cli.mcp_validators import validate_mcp_config_structure
+from glaip_sdk.icons import ICON_TOOL
+
+from ._common import _resolve_mcp, console, mcps_group
+
+MAX_DESCRIPTION_LEN = 50
+
+
+def _get_tools_from_config(ctx: Any, client: Any, config_file: str) -> tuple[list[dict[str, Any]], str]:
+    """Get tools from MCP config file.
+
+    Args:
+        ctx: Click context
+        client: GlaIP client instance
+        config_file: Path to config file
+
+    Returns:
+        Tuple of (tools list, title string)
+    """
+    config_data = load_resource_from_file_with_validation(Path(config_file), "MCP config")
+
+    # Validate config structure
+    transport = config_data.get("transport")
+    if "config" not in config_data:
+        raise click.ClickException("Invalid MCP config: missing 'config' section in the file.")
+    config_data["config"] = validate_mcp_config_structure(
+        config_data["config"],
+        transport=transport,
+        source=config_file,
+    )
+
+    # Get tools from config without saving
+    with spinner_context(
+        ctx,
+        "[bold blue]Fetching tools from config…[/bold blue]",
+        console_override=console,
+    ):
+        tools = client.mcps.get_mcp_tools_from_config(config_data)
+
+    title = f"{ICON_TOOL} Tools from config: {Path(config_file).name}"
+    return tools, title
+
+
+def _get_tools_from_mcp(ctx: Any, client: Any, mcp_ref: str | None) -> tuple[list[dict[str, Any]], str]:
+    """Get tools from saved MCP.
+
+    Args:
+        ctx: Click context
+        client: GlaIP client instance
+        mcp_ref: MCP reference (ID or name)
+
+    Returns:
+        Tuple of (tools list, title string)
+    """
+    mcp = _resolve_mcp(ctx, client, mcp_ref)
+
+    with spinner_context(
+        ctx,
+        "[bold blue]Fetching MCP tools…[/bold blue]",
+        console_override=console,
+    ):
+        tools = client.mcps.get_mcp_tools(mcp.id)
+
+    title = f"{ICON_TOOL} Tools from MCP: {mcp.name}"
+    return tools, title
+
+
+def _output_tool_names(ctx: Any, tools: list[dict[str, Any]]) -> None:
+    """Output only tool names.
+
+    Args:
+        ctx: Click context
+        tools: List of tool dictionaries
+    """
+    view = get_ctx_value(ctx, "view", "rich")
+    tool_names = [tool.get("name", "N/A") for tool in tools]
+
+    if view == "json":
+        handle_json_output(ctx, tool_names)
+    elif view == "plain":
+        if tool_names:
+            for name in tool_names:
+                console.print(name, markup=False)
+            console.print(f"Total: {len(tool_names)} tools", markup=False)
+        else:
+            console.print("No tools found", markup=False)
+    else:
+        if tool_names:
+            for name in tool_names:
+                console.print(name)
+            console.print(f"[dim]Total: {len(tool_names)} tools[/dim]")
+        else:
+            console.print("[yellow]No tools found[/yellow]")
+
+
+def _transform_tool(tool: dict[str, Any]) -> dict[str, Any]:
+    """Transform a tool dictionary to a display row dictionary.
+
+    Args:
+        tool: Tool dictionary to transform.
+
+    Returns:
+        Dictionary with name and description fields.
+    """
+    description = tool.get("description", "N/A")
+    if len(description) > MAX_DESCRIPTION_LEN:
+        description = description[: MAX_DESCRIPTION_LEN - 3] + "..."
+    return {
+        "name": tool.get("name", "N/A"),
+        "description": description,
+    }
+
+
+def _output_tools_table(ctx: Any, tools: list[dict[str, Any]], title: str) -> None:
+    """Output tools in table format.
+
+    Args:
+        ctx: Click context
+        tools: List of tool dictionaries
+        title: Table title
+    """
+    columns = [
+        ("name", "Name", ACCENT_STYLE, None),
+        ("description", "Description", INFO, 50),
+    ]
+
+    output_list(
+        ctx,
+        tools,
+        title,
+        columns,
+        _transform_tool,
+    )
+
+
+def _validate_tool_command_args(mcp_ref: str | None, config_file: str | None) -> None:
+    """Validate that exactly one of mcp_ref or config_file is provided.
+
+    Args:
+        mcp_ref: MCP reference (ID or name)
+        config_file: Path to config file
+
+    Raises:
+        ClickException: If validation fails
+    """
+    if not mcp_ref and not config_file:
+        raise click.ClickException(
+            "Either MCP_REF or --from-config must be provided.\n"
+            "Examples:\n"
+            "  aip mcps tools <MCP_ID>\n"
+            "  aip mcps tools --from-config mcp-config.json"
+        )
+    if mcp_ref and config_file:
+        raise click.ClickException(
+            "Cannot use both MCP_REF and --from-config at the same time.\n"
+            "Use either:\n"
+            "  aip mcps tools <MCP_ID>\n"
+            "  aip mcps tools --from-config mcp-config.json"
+        )
+
+
+@mcps_group.command("tools")
+@click.argument("mcp_ref", required=False)
+@click.option(
+    "--from-config",
+    "--config",
+    "config_file",
+    type=click.Path(exists=True, dir_okay=False),
+    help="Get tools from MCP config file without saving to DB (JSON or YAML)",
+)
+@click.option(
+    "--names-only",
+    is_flag=True,
+    help="Show only tool names (useful for allowed_tools config)",
+)
+@output_flags()
+@click.pass_context
+def list_tools(ctx: Any, mcp_ref: str | None, config_file: str | None, names_only: bool) -> None:
+    """List tools available from a specific MCP or config file.
+
+    Args:
+        ctx: Click context containing output format preferences
+        mcp_ref: MCP reference (ID or name) - required if --from-config not used
+        config_file: Path to MCP config file - alternative to mcp_ref
+        names_only: Show only tool names instead of full table
+
+    Raises:
+        ClickException: If MCP not found or tools fetch fails
+
+    Examples:
+        Get tools from saved MCP:
+            aip mcps tools <MCP_ID>
+
+        Get tools from config file (without saving to DB):
+            aip mcps tools --from-config mcp-config.json
+
+        Get just tool names for allowed_tools config:
+            aip mcps tools <MCP_ID> --names-only
+    """
+    try:
+        _validate_tool_command_args(mcp_ref, config_file)
+        client = get_client(ctx)
+
+        if config_file:
+            tools, title = _get_tools_from_config(ctx, client, config_file)
+        else:
+            tools, title = _get_tools_from_mcp(ctx, client, mcp_ref)
+
+        if names_only:
+            _output_tool_names(ctx, tools)
+        else:
+            _output_tools_table(ctx, tools, title)
+
+    except Exception as e:
+        raise click.ClickException(str(e)) from e

glaip_sdk/cli/commands/mcps/update.py

@@ -0,0 +1,146 @@
+"""Update MCP command.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from glaip_sdk.cli.context import output_flags
+from glaip_sdk.cli.display import display_update_success, handle_json_output, handle_rich_output
+from glaip_sdk.cli.core.context import get_client
+from glaip_sdk.cli.core.rendering import spinner_context
+
+from ._common import (
+    _assemble_update_data_from_cli_options,
+    _assemble_update_data_from_import_payload,
+    _handle_cli_error,
+    _handle_update_preview_and_confirmation,
+    _load_import_ready_payload,
+    _resolve_mcp,
+    _validate_import_payload_fields,
+    _validate_update_inputs,
+    console,
+    mcps_group,
+)
+
+
+@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",
+    help="JSON configuration string or @file reference (e.g., @config.json)",
+)
+@click.option(
+    "--auth",
+    "--authentication",
+    "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:
+    r"""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:
+        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.
+
+    \b
+    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
+        _validate_update_inputs(name, transport, description, config, auth, import_file)
+
+        # Resolve MCP using helper function
+        mcp = _resolve_mcp(ctx, client, mcp_ref)
+
+        # 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 payload and CLI options
+        update_data = _assemble_update_data_from_import_payload(import_payload)
+        update_data = _assemble_update_data_from_cli_options(
+            update_data, name, transport, description, config, auth, import_payload, mcp
+        )
+
+        if not update_data:
+            raise click.ClickException("No update fields specified")
+
+        # Show confirmation preview for import-based updates (unless -y flag)
+        if not _handle_update_preview_and_confirmation(
+            import_payload, y, mcp, update_data, name, transport, description, config, auth
+        ):
+            return
+
+        # Update MCP
+        with spinner_context(
+            ctx,
+            "[bold blue]Updating MCP…[/bold blue]",
+            console_override=console,
+        ):
+            updated_mcp = client.mcps.update_mcp(mcp, **update_data)
+
+        handle_json_output(ctx, updated_mcp.model_dump())
+        handle_rich_output(ctx, display_update_success("MCP", updated_mcp.name))
+
+    except Exception as e:
+        _handle_cli_error(ctx, e, "MCP update")

glaip_sdk/cli/commands/shared/__init__.py

@@ -0,0 +1,21 @@
+"""Shared CLI command helpers.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from glaip_sdk.cli.commands.shared.formatters import (
+    _format_empty_override_warnings,
+    _format_dict_value,
+    _format_preview_value,
+    _is_sensitive_data,
+    _redact_sensitive_dict,
+)
+
+__all__ = [
+    "_format_empty_override_warnings",
+    "_format_dict_value",
+    "_format_preview_value",
+    "_is_sensitive_data",
+    "_redact_sensitive_dict",
+]

glaip_sdk/cli/commands/shared/formatters.py

@@ -0,0 +1,91 @@
+"""Shared formatting helpers for CLI commands.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import json
+from typing import Any
+
+
+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 _format_empty_override_warnings(empty_fields: list[str]) -> list[str]:
+    """Format 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

glaip_sdk/cli/commands/tools/__init__.py

@@ -0,0 +1,69 @@
+"""Tool CLI commands package.
+
+This package contains tool management commands split by operation.
+The package is the canonical import surface.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+# pylint: disable=duplicate-code
+from glaip_sdk.cli.commands.tools._common import tools_group, _resolve_tool, console
+from glaip_sdk.cli.commands.tools.create import create  # noqa: E402
+from glaip_sdk.cli.commands.tools.delete import delete  # noqa: E402
+from glaip_sdk.cli.commands.tools.get import get  # noqa: E402
+from glaip_sdk.cli.commands.tools.list import list_tools  # noqa: E402
+from glaip_sdk.cli.commands.tools.script import script  # noqa: E402
+from glaip_sdk.cli.commands.tools.update import update  # noqa: E402
+
+# Import helper functions from create module for backward compatibility
+from glaip_sdk.cli.commands.tools.create import (  # noqa: E402
+    _check_duplicate_name,
+    _create_tool_from_file,
+    _extract_internal_name,
+    _handle_import_file,
+    _parse_tags,
+    _validate_name_match,
+)
+
+# Import core functions for test compatibility
+from glaip_sdk.cli.core.context import get_client  # noqa: E402
+from glaip_sdk.cli.core.output import (  # noqa: E402
+    output_list,
+    output_result,
+)
+from glaip_sdk.cli.core.rendering import spinner_context  # noqa: E402
+
+# Import IO functions for test compatibility
+from glaip_sdk.cli.io import (  # noqa: E402
+    fetch_raw_resource_details,
+    load_resource_from_file_with_validation,
+)
+
+# Alias for backward compatibility (used in create.py)
+load_resource_from_file = load_resource_from_file_with_validation
+
+__all__ = [
+    "tools_group",
+    "create",
+    "delete",
+    "get",
+    "list_tools",
+    "script",
+    "update",
+    "_check_duplicate_name",
+    "_create_tool_from_file",
+    "_extract_internal_name",
+    "_handle_import_file",
+    "_parse_tags",
+    "_resolve_tool",
+    "_validate_name_match",
+    "console",
+    "get_client",
+    "output_list",
+    "output_result",
+    "spinner_context",
+    "fetch_raw_resource_details",
+    "load_resource_from_file_with_validation",
+    "load_resource_from_file",
+]

glaip_sdk/cli/commands/tools/_common.py

@@ -0,0 +1,80 @@
+"""Common helpers and group definition for tool commands.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+from rich.console import Console
+
+from glaip_sdk.cli.core.context import get_client
+from glaip_sdk.cli.core.rendering import spinner_context
+from glaip_sdk.cli.resolution import resolve_resource_reference
+
+console = Console()
+
+
+@click.group(name="tools", no_args_is_help=True)
+def tools_group() -> None:
+    """Tool management operations."""
+    pass
+
+
+def _resolve_tool(ctx: Any, client: Any, ref: str, select: int | None = None) -> Any | None:
+    """Resolve a tool by ID or name, handling ambiguous matches interactively.
+
+    This function provides tool-specific resolution logic. It uses
+    resolve_resource_reference to find tools by UUID or name, with interactive
+    selection when multiple matches are found.
+
+    Args:
+        ctx: Click context for CLI operations.
+        client: API client instance.
+        ref: Tool reference (UUID string or name).
+        select: Pre-selected index for non-interactive mode (1-based).
+
+    Returns:
+        Tool object if found, None otherwise.
+    """
+    # Configure tool-specific resolution with standard fuzzy matching
+    get_by_id = client.get_tool
+    find_by_name = client.find_tools
+    return resolve_resource_reference(
+        ctx,
+        client,
+        ref,
+        "tool",
+        get_by_id,
+        find_by_name,
+        "Tool",
+        select=select,
+    )
+
+
+def _get_tool_by_id_with_spinner(ctx: Any, tool_id: str) -> Any:
+    """Get tool by ID with spinner context and error handling.
+
+    Args:
+        ctx: Click context.
+        tool_id: Tool ID to fetch.
+
+    Returns:
+        Tool object.
+
+    Raises:
+        click.ClickException: If tool not found.
+    """
+    client = get_client(ctx)
+    try:
+        with spinner_context(
+            ctx,
+            "[bold blue]Fetching tool…[/bold blue]",
+            console_override=console,
+        ):
+            return client.get_tool_by_id(tool_id)
+    except Exception as e:
+        raise click.ClickException(f"Tool with ID '{tool_id}' not found: {e}") from e