glaip-sdk 0.6.19__py3-none-any.whl → 0.7.27__py3-none-any.whl

glaip_sdk/cli/commands/mcps/update.py

@@ -0,0 +1,190 @@
+"""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 (
+    _handle_cli_error,
+    _handle_update_preview_and_confirmation,
+    _load_import_ready_payload,
+    _parse_and_validate_config_auth,
+    _resolve_mcp,
+    _validate_import_payload_fields,
+    _validate_update_inputs,
+    console,
+    mcps_group,
+)
+
+
+def _merge_update_kwargs(
+    import_payload: dict[str, Any] | None,
+    name: str | None,
+    transport: str | None,
+    description: str | None,
+    config: str | None,
+    auth: str | None,
+    mcp: Any,
+) -> dict[str, Any]:
+    """Merge import payload and CLI options into kwargs for SDK builder.
+
+    Args:
+        import_payload: Import payload dictionary or None
+        name: MCP name option
+        transport: Transport option
+        description: Description option
+        config: Config option
+        auth: Auth option
+        mcp: Current MCP object
+
+    Returns:
+        Dictionary with merged update kwargs
+    """
+    update_kwargs: dict[str, Any] = {}
+
+    # Start with import payload fields
+    if import_payload:
+        for field in ("name", "transport", "description", "config", "authentication"):
+            if field in import_payload:
+                update_kwargs[field] = import_payload[field]
+
+    # Override with CLI options (CLI takes precedence)
+    if name is not None:
+        update_kwargs["name"] = name
+    if transport is not None:
+        update_kwargs["transport"] = transport
+    if description is not None:
+        update_kwargs["description"] = description
+    _parse_and_validate_config_auth(update_kwargs, config, auth, transport, import_payload, mcp)
+
+    return update_kwargs
+
+
+@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.
+        Method selection (PATCH vs PUT) is handled automatically by the SDK client
+        based on the fields provided.
+
+    \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
+
+        # Merge import payload and CLI options into kwargs for SDK builder
+        update_kwargs = _merge_update_kwargs(import_payload, name, transport, description, config, auth, mcp)
+
+        if not update_kwargs:
+            raise click.ClickException("No update fields specified")
+
+        # Build preview data for confirmation (using the same structure as before)
+        preview_data = update_kwargs.copy()
+
+        # Show confirmation preview for import-based updates (unless -y flag)
+        if not _handle_update_preview_and_confirmation(
+            import_payload, y, mcp, preview_data, name, transport, description, config, auth
+        ):
+            return
+
+        # Use SDK client method to update MCP
+        # Pass mcp object (not mcp.id) to avoid extra fetch; SDK accepts str | MCP
+        with spinner_context(
+            ctx,
+            "[bold blue]Updating MCP…[/bold blue]",
+            console_override=console,
+        ):
+            updated_mcp = client.mcps.update_mcp(mcp, **update_kwargs)
+
+        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/models.py

@@ -11,10 +11,8 @@ 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 (
-    output_list,
-    with_client_and_spinner,
-)
+from glaip_sdk.cli.core.output import output_list
+from glaip_sdk.cli.core.rendering import with_client_and_spinner
 
 console = Console()
 

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

glaip_sdk/cli/commands/tools/create.py

@@ -0,0 +1,228 @@
+"""Create tool command.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+import click
+
+from glaip_sdk.cli.context import get_ctx_value, output_flags
+from glaip_sdk.cli.core.context import get_client, handle_best_effort_check
+from glaip_sdk.cli.core.rendering import spinner_context
+from glaip_sdk.cli.display import (
+    display_api_error,
+    display_creation_success,
+    handle_json_output,
+    handle_rich_output,
+)
+from glaip_sdk.cli.io import load_resource_from_file_with_validation as load_resource_from_file
+from glaip_sdk.utils.import_export import merge_import_with_cli_args
+
+from ._common import console, tools_group
+
+
+def _extract_internal_name(code: str) -> str:
+    """Extract plugin class name attribute from tool code."""
+    m = re.search(r'^\s*name\s*:\s*str\s*=\s*"([^"]+)"', code, re.M)
+    if not m:
+        m = re.search(r'^\s*name\s*=\s*"([^"]+)"', code, re.M)
+    if not m:
+        raise click.ClickException(
+            "Could not find plugin 'name' attribute in the tool file. "
+            'Ensure your plugin class defines e.g. name: str = "my_tool".'
+        )
+    return m.group(1)
+
+
+def _validate_name_match(provided: str | None, internal: str) -> str:
+    """Validate provided --name against internal name; return effective name."""
+    if provided and provided != internal:
+        raise click.ClickException(
+            f"--name '{provided}' does not match plugin internal name '{internal}'. "
+            "Either update the code or pass a matching --name."
+        )
+    return provided or internal
+
+
+def _check_duplicate_name(client: Any, tool_name: str) -> None:
+    """Raise if a tool with the same name already exists."""
+
+    def _check_duplicate() -> None:
+        existing = client.find_tools(name=tool_name)
+        if existing:
+            raise click.ClickException(
+                f"A tool named '{tool_name}' already exists. "
+                "Please change your plugin's 'name' to a unique value, then re-run."
+            )
+
+    handle_best_effort_check(_check_duplicate)
+
+
+def _parse_tags(tags: str | None) -> list[str]:
+    """Return a cleaned list of tag strings from a comma-separated input."""
+    return [t.strip() for t in (tags.split(",") if tags else []) if t.strip()]
+
+
+def _handle_import_file(
+    import_file: str | None,
+    name: str | None,
+    description: str | None,
+    tags: str | None,
+) -> dict[str, Any]:
+    """Handle import file logic and merge with CLI arguments."""
+    if import_file:
+        import_data = load_resource_from_file(Path(import_file), "tool")
+
+        # Merge CLI args with imported data
+        cli_args = {
+            "name": name,
+            "description": description,
+            "tags": tags,
+        }
+
+        return merge_import_with_cli_args(import_data, cli_args)
+    else:
+        # No import file - use CLI args directly
+        return {
+            "name": name,
+            "description": description,
+            "tags": tags,
+        }
+
+
+def _create_tool_from_file(
+    client: Any,
+    file_path: str,
+    name: str | None,
+    description: str | None,
+    tags: str | None,
+) -> Any:
+    """Create tool from file upload."""
+    with open(file_path, encoding="utf-8") as f:
+        code_content = f.read()
+
+    internal_name = _extract_internal_name(code_content)
+    tool_name = _validate_name_match(name, internal_name)
+    _check_duplicate_name(client, tool_name)
+
+    # Upload the plugin code as-is (no rewrite)
+    return client.create_tool_from_code(
+        name=tool_name,
+        code=code_content,
+        framework="langchain",  # Always langchain
+        description=description,
+        tags=_parse_tags(tags) if tags else None,
+    )
+
+
+def _validate_creation_parameters(
+    file: str | None,
+    import_file: str | None,
+) -> None:
+    """Validate required parameters for tool creation."""
+    if not file and not import_file:
+        raise click.ClickException("A tool file must be provided. Use --file to specify the tool file to upload.")
+
+
+@tools_group.command()
+@click.argument("file_arg", required=False, type=click.Path(exists=True))
+@click.option(
+    "--file",
+    type=click.Path(exists=True),
+    help="Tool file to upload",
+)
+@click.option(
+    "--name",
+    help="Tool name (extracted from script if file provided)",
+)
+@click.option(
+    "--description",
+    help="Tool description (extracted from script if file provided)",
+)
+@click.option(
+    "--tags",
+    help="Comma-separated tags for the tool",
+)
+@click.option(
+    "--import",
+    "import_file",
+    type=click.Path(exists=True, dir_okay=False),
+    help="Import tool configuration from JSON file",
+)
+@output_flags()
+@click.pass_context
+def create(
+    ctx: Any,
+    file_arg: str | None,
+    file: str | None,
+    name: str | None,
+    description: str | None,
+    tags: str | None,
+    import_file: str | None,
+) -> None:
+    r"""Create a new tool.
+
+    \b
+    Examples:
+        aip tools create tool.py  # Create from file
+        aip tools create --import tool.json  # Create from exported configuration
+    """
+    try:
+        client = get_client(ctx)
+
+        # Allow positional file argument for better DX (matches examples)
+        if not file and file_arg:
+            file = file_arg
+
+        # Handle import file and merge with CLI arguments
+        merged_data = _handle_import_file(import_file, name, description, tags)
+
+        # Extract merged values
+        name = merged_data.get("name")
+        description = merged_data.get("description")
+        tags_raw = merged_data.get("tags")
+        # Convert tags to string format (for _create_tool_from_file which expects str | None)
+        # Import data may have tags as list, CLI provides string
+        if isinstance(tags_raw, list):
+            tags = ",".join(str(tag).strip() for tag in tags_raw) if tags_raw else None
+        else:
+            tags = tags_raw  # Already string or None
+
+        # Validate required parameters
+        _validate_creation_parameters(file, import_file)
+
+        # Create tool from file (either direct file or import file)
+        with spinner_context(
+            ctx,
+            "[bold blue]Creating tool…[/bold blue]",
+            console_override=console,
+        ):
+            tool = _create_tool_from_file(client, file, name, description, tags)
+
+        # Handle JSON output
+        handle_json_output(ctx, tool.model_dump())
+
+        # Handle Rich output
+        creation_method = "file upload (custom)"
+        rich_panel = display_creation_success(
+            "Tool",
+            tool.name,
+            tool.id,
+            Framework=getattr(tool, "framework", "N/A"),
+            Type=getattr(tool, "tool_type", "N/A"),
+            Description=getattr(tool, "description", "No description"),
+            Method=creation_method,
+        )
+        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, "tool creation")
+        raise click.ClickException(str(e)) from e