glaip-sdk 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

glaip_sdk/cli/commands/mcps.py

@@ -24,7 +24,13 @@ from glaip_sdk.cli.display import (
 )
 from glaip_sdk.cli.io import (
     fetch_raw_resource_details,
+    load_resource_from_file_with_validation,
 )
+from glaip_sdk.cli.mcp_validators import (
+    validate_mcp_auth_structure,
+    validate_mcp_config_structure,
+)
+from glaip_sdk.cli.parsers.json_input import parse_json_input
 from glaip_sdk.cli.resolution import resolve_resource_reference
 from glaip_sdk.cli.utils import (
     coerce_to_row,
@@ -36,8 +42,12 @@ from glaip_sdk.cli.utils import (
     output_result,
     spinner_context,
 )
+from glaip_sdk.config.constants import (
+    DEFAULT_MCP_TYPE,
+)
 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
 from glaip_sdk.utils.serialization import (
     build_mcp_export_payload,
     write_resource_export,
@@ -85,6 +95,180 @@ def _resolve_mcp(
     )
 
 
+def _strip_server_only_fields(import_data: dict[str, Any]) -> dict[str, Any]:
+    """Remove fields that should not be forwarded during import-driven creation.
+
+    Args:
+        import_data: Raw import payload loaded from disk.
+
+    Returns:
+        A shallow copy of the data with server-managed fields removed.
+    """
+    cleaned = dict(import_data)
+    for key in (
+        "id",
+        "type",
+        "status",
+        "connection_status",
+        "created_at",
+        "updated_at",
+    ):
+        cleaned.pop(key, None)
+    return cleaned
+
+
+def _load_import_ready_payload(import_file: str) -> dict[str, Any]:
+    """Load and normalise an imported MCP definition for create operations.
+
+    Args:
+        import_file: Path to an MCP export file (JSON or YAML).
+
+    Returns:
+        Normalised import payload ready for CLI/REST usage.
+
+    Raises:
+        click.ClickException: If the file cannot be parsed or validated.
+    """
+    raw_data = load_resource_from_file_with_validation(Path(import_file), "MCP")
+    import_data = convert_export_to_import_format(raw_data)
+    import_data = _strip_server_only_fields(import_data)
+
+    transport = import_data.get("transport")
+
+    if "config" in import_data:
+        import_data["config"] = validate_mcp_config_structure(
+            import_data["config"],
+            transport=transport,
+            source="import file",
+        )
+
+    if "authentication" in import_data:
+        import_data["authentication"] = validate_mcp_auth_structure(
+            import_data["authentication"],
+            source="import file",
+        )
+
+    return import_data
+
+
+def _coerce_cli_string(value: str | None) -> str | None:
+    """Normalise CLI string values so blanks are treated as missing.
+
+    Args:
+        value: User-provided string option.
+
+    Returns:
+        The stripped string, or ``None`` when the value is blank/whitespace-only.
+    """
+    if value is None:
+        return None
+    trimmed = value.strip()
+    # Treat whitespace-only strings as None
+    return trimmed if trimmed else None
+
+
+def _merge_config_field(
+    merged_base: dict[str, Any],
+    cli_config: str | None,
+    final_transport: str | None,
+) -> None:
+    """Merge config field with validation.
+
+    Args:
+        merged_base: Base payload to update in-place.
+        cli_config: Raw CLI JSON string for config.
+        final_transport: Transport type for validation.
+
+    Raises:
+        click.ClickException: If config JSON parsing or validation fails.
+    """
+    if cli_config is not None:
+        parsed_config = parse_json_input(cli_config)
+        merged_base["config"] = validate_mcp_config_structure(
+            parsed_config,
+            transport=final_transport,
+            source="--config",
+        )
+    elif "config" not in merged_base or merged_base["config"] is None:
+        merged_base["config"] = {}
+
+
+def _merge_auth_field(
+    merged_base: dict[str, Any],
+    cli_auth: str | None,
+) -> None:
+    """Merge authentication field with validation.
+
+    Args:
+        merged_base: Base payload to update in-place.
+        cli_auth: Raw CLI JSON string for authentication.
+
+    Raises:
+        click.ClickException: If auth JSON parsing or validation fails.
+    """
+    if cli_auth is not None:
+        parsed_auth = parse_json_input(cli_auth)
+        merged_base["authentication"] = validate_mcp_auth_structure(
+            parsed_auth,
+            source="--auth",
+        )
+    elif "authentication" not in merged_base:
+        merged_base["authentication"] = None
+
+
+def _merge_import_payload(
+    import_data: dict[str, Any] | None,
+    *,
+    cli_name: str | None,
+    cli_transport: str | None,
+    cli_description: str | None,
+    cli_config: str | None,
+    cli_auth: str | None,
+) -> tuple[dict[str, Any], list[str]]:
+    """Merge import data with CLI overrides while tracking missing fields.
+
+    Args:
+        import_data: Normalised payload loaded from file (if provided).
+        cli_name: Name supplied via CLI option.
+        cli_transport: Transport supplied via CLI option.
+        cli_description: Description supplied via CLI option.
+        cli_config: Raw CLI JSON string for config.
+        cli_auth: Raw CLI JSON string for authentication.
+
+    Returns:
+        A tuple of (merged_payload, missing_required_fields).
+
+    Raises:
+        click.ClickException: If config/auth JSON parsing or validation fails.
+    """
+    merged_base = import_data.copy() if import_data else {}
+
+    # Merge simple string fields using truthy CLI overrides
+    for field, cli_value in (
+        ("name", _coerce_cli_string(cli_name)),
+        ("transport", _coerce_cli_string(cli_transport)),
+        ("description", _coerce_cli_string(cli_description)),
+    ):
+        if cli_value is not None:
+            merged_base[field] = cli_value
+
+    # Determine final transport before validating config
+    final_transport = merged_base.get("transport")
+
+    # Merge config and authentication with validation
+    _merge_config_field(merged_base, cli_config, final_transport)
+    _merge_auth_field(merged_base, cli_auth)
+
+    # Validate required fields
+    missing_fields = []
+    for required in ("name", "transport"):
+        value = merged_base.get(required)
+        if not isinstance(value, str) or not value.strip():
+            missing_fields.append(required)
+
+    return merged_base, missing_fields
+
+
 @mcps_group.command(name="list")
 @output_flags()
 @click.pass_context
@@ -134,50 +318,114 @@ def list_mcps(ctx: Any) -> None:
 
 
 @mcps_group.command()
-@click.option("--name", required=True, help="MCP name")
-@click.option("--transport", required=True, help="MCP transport protocol")
+@click.option("--name", help="MCP name")
+@click.option("--transport", help="MCP transport protocol")
 @click.option("--description", help="MCP description")
-@click.option("--config", help="JSON configuration string")
+@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),
+    help="Import MCP configuration from JSON or YAML export",
+)
 @output_flags()
 @click.pass_context
 def create(
-    ctx: Any, name: str, transport: str, description: str | None, config: str | None
+    ctx: Any,
+    name: str | None,
+    transport: str | None,
+    description: str | None,
+    config: str | None,
+    auth: str | None,
+    import_file: str | None,
 ) -> None:
     """Create a new MCP with specified configuration.
 
+    You can create an MCP by providing all parameters via CLI options, or by
+    importing from a file and optionally overriding specific fields.
+
     Args:
         ctx: Click context containing output format preferences
-        name: MCP name (required)
-        transport: MCP transport protocol (required)
+        name: MCP name (required unless provided via --import)
+        transport: MCP transport protocol (required unless provided via --import)
         description: Optional MCP description
-        config: JSON configuration string for MCP settings
+        config: JSON configuration string or @file reference
+        auth: JSON authentication object or @file reference
+        import_file: Optional path to import configuration from export file.
+            CLI options override imported values.
 
     Raises:
         ClickException: If JSON parsing fails or API request fails
+
+    Examples:
+        Create from CLI options:
+            aip mcps create --name my-mcp --transport http --config '{"url": "https://api.example.com"}'
+
+        Import from file:
+            aip mcps create --import mcp-export.json
+
+        Import with overrides:
+            aip mcps create --import mcp-export.json --name new-name --transport sse
     """
     try:
         client = get_client(ctx)
 
-        # Parse config if provided
-        mcp_config = {}
-        if config:
-            try:
-                mcp_config = json.loads(config)
-            except json.JSONDecodeError:
-                raise click.ClickException("Invalid JSON in --config")
+        import_payload = (
+            _load_import_ready_payload(import_file) if import_file is not None else None
+        )
+
+        merged_payload, missing_fields = _merge_import_payload(
+            import_payload,
+            cli_name=name,
+            cli_transport=transport,
+            cli_description=description,
+            cli_config=config,
+            cli_auth=auth,
+        )
+
+        if missing_fields:
+            raise click.ClickException(
+                "Missing required fields after combining import and CLI values: "
+                + ", ".join(missing_fields)
+            )
+
+        effective_name = merged_payload["name"]
+        effective_transport = merged_payload["transport"]
+        effective_description = merged_payload.get("description")
+        effective_config = merged_payload.get("config") or {}
+        effective_auth = merged_payload.get("authentication")
 
         with spinner_context(
             ctx,
             "[bold blue]Creating MCP…[/bold blue]",
             console_override=console,
         ):
-            mcp = client.mcps.create_mcp(
-                name=name,
-                type="server",  # MCPs are always server type
-                transport=transport,
-                description=description,
-                config=mcp_config,
-            )
+            create_kwargs: dict[str, Any] = {
+                "name": effective_name,
+                "config": effective_config,
+                "transport": effective_transport,
+            }
+
+            if effective_description is not None:
+                create_kwargs["description"] = effective_description
+
+            if effective_auth:
+                create_kwargs["authentication"] = effective_auth
+
+            mcp_metadata = merged_payload.get("mcp_metadata")
+            if mcp_metadata is not None:
+                create_kwargs["mcp_metadata"] = mcp_metadata
+
+            mcp = client.mcps.create_mcp(**create_kwargs)
 
         # Handle JSON output
         handle_json_output(ctx, mcp.model_dump())
@@ -187,9 +435,9 @@ def create(
             "MCP",
             mcp.name,
             mcp.id,
-            Type="server",
-            Transport=getattr(mcp, "transport", transport),
-            Description=description or "No description",
+            Type=getattr(mcp, "type", DEFAULT_MCP_TYPE),
+            Transport=getattr(mcp, "transport", effective_transport),
+            Description=effective_description or "No description",
         )
         handle_rich_output(ctx, rich_panel)
 
@@ -437,7 +685,6 @@ def list_tools(ctx: Any, mcp_ref: str) -> None:
         columns = [
             ("name", "Name", "cyan", None),
             ("description", "Description", "green", 50),
-            ("type", "Type", "yellow", None),
         ]
 
         # Transform function for safe dictionary access
@@ -447,7 +694,6 @@ def list_tools(ctx: Any, mcp_ref: str) -> None:
                 "description": tool.get("description", "N/A")[:47] + "..."
                 if len(tool.get("description", "")) > 47
                 else tool.get("description", "N/A"),
-                "type": tool.get("type", "N/A"),
             }
 
         output_list(
@@ -525,7 +771,16 @@ def connect(ctx: Any, config_file: str) -> None:
 @click.argument("mcp_ref")
 @click.option("--name", help="New MCP name")
 @click.option("--description", help="New description")
-@click.option("--config", help="JSON configuration string")
+@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)",
+)
 @output_flags()
 @click.pass_context
 def update(
@@ -534,6 +789,7 @@ def update(
     name: str | None,
     description: str | None,
     config: str | None,
+    auth: str | None,
 ) -> None:
     """Update an existing MCP with new configuration values.
 
@@ -542,7 +798,8 @@ def update(
         mcp_ref: MCP reference (ID or name)
         name: New MCP name (optional)
         description: New description (optional)
-        config: New JSON configuration string (optional)
+        config: New JSON configuration string or @file reference (optional)
+        auth: New JSON authentication object or @file reference (optional)
 
     Raises:
         ClickException: If MCP not found, JSON invalid, or no fields specified
@@ -564,10 +821,17 @@ def update(
         if description is not None:
             update_data["description"] = description
         if config is not None:
-            try:
-                update_data["config"] = json.loads(config)
-            except json.JSONDecodeError:
-                raise click.ClickException("Invalid JSON in --config")
+            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"
+            )
 
         if not update_data:
             raise click.ClickException("No update fields specified")

glaip_sdk/cli/mcp_validators.py

@@ -0,0 +1,297 @@
+"""MCP configuration and authentication validation for CLI.
+
+This module provides validation functions for MCP config and auth structures
+that are used in CLI commands. It ensures data conforms to the MCP schema
+documented in docs/reference/schemas/mcps.md.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+from typing import Any
+from urllib.parse import urlparse
+
+import click
+
+
+def format_validation_error(prefix: str, detail: str | None = None) -> str:
+    """Format a validation error message with optional detail.
+
+    Args:
+        prefix: Main error message
+        detail: Optional additional detail to append
+
+    Returns:
+        Formatted error message string
+
+    Examples:
+        >>> format_validation_error("Invalid config", "Missing 'url' field")
+        "Invalid config\\nMissing 'url' field"
+    """
+    parts = [prefix]
+    if detail:
+        parts.append(detail)
+    return "\n".join(parts)
+
+
+def validate_mcp_config_structure(
+    config: Any, *, transport: str | None = None, source: str = "--config"
+) -> dict[str, Any]:
+    """Validate MCP configuration structure for CLI commands.
+
+    Validates that the config is a dictionary with a valid 'url' field.
+    The 'url' must be an absolute HTTP/HTTPS URL as required by the MCP schema.
+
+    Args:
+        config: Configuration value to validate (expected to be a dict)
+        transport: Optional transport type ('http' or 'sse') for context in errors
+        source: Source parameter name for error messages (default: "--config")
+
+    Returns:
+        Validated configuration dictionary
+
+    Raises:
+        click.ClickException: If config is not a dict, missing 'url', or URL is invalid
+
+    Examples:
+        >>> validate_mcp_config_structure({"url": "https://api.example.com"})
+        {'url': 'https://api.example.com'}
+
+        >>> validate_mcp_config_structure([1, 2, 3])  # doctest: +SKIP
+        ClickException: Invalid --config value
+        Expected a JSON object representing MCP configuration.
+
+    Schema Reference:
+        See docs/reference/schemas/mcps.md - Config Object Structure
+        - Required field: 'url' (string, must be valid HTTP/HTTPS URL)
+        - Additional fields allowed and passed through
+    """
+    if not isinstance(config, dict):
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "Expected a JSON object representing MCP configuration.",
+            )
+        )
+
+    url_value = config.get("url")
+    if not isinstance(url_value, str) or not url_value.strip():
+        requirement = "Missing required 'url' field with a non-empty string value."
+        if transport:
+            requirement += f" Required for transport '{transport}'."
+        raise click.ClickException(
+            format_validation_error(f"Invalid {source} value", requirement)
+        )
+
+    parsed_url = urlparse(url_value)
+    if parsed_url.scheme not in {"http", "https"} or not parsed_url.netloc:
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "'url' must be an absolute HTTP or HTTPS URL.",
+            )
+        )
+
+    return config
+
+
+def _validate_headers_mapping(
+    headers: Any, *, source: str, context: str
+) -> dict[str, str]:
+    """Validate headers mapping for authentication.
+
+    Args:
+        headers: Headers value to validate (expected to be a non-empty dict)
+        source: Source parameter name for error messages
+        context: Context description for error messages (e.g., "bearer-token authentication")
+
+    Returns:
+        Validated headers dictionary with string keys and values
+
+    Raises:
+        click.ClickException: If headers is not a dict, empty, or contains invalid entries
+    """
+    if not isinstance(headers, dict) or not headers:
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                f"{context} must provide a non-empty 'headers' object with string keys and values.",
+            )
+        )
+
+    normalized: dict[str, str] = {}
+    for key, value in headers.items():
+        if not isinstance(key, str) or not key.strip():
+            raise click.ClickException(
+                format_validation_error(
+                    f"Invalid {source} value",
+                    "Header names must be non-empty strings.",
+                )
+            )
+        if not isinstance(value, str) or not value.strip():
+            raise click.ClickException(
+                format_validation_error(
+                    f"Invalid {source} value",
+                    f"Header '{key}' must have a non-empty string value.",
+                )
+            )
+        normalized[key] = value
+    return normalized
+
+
+def _validate_bearer_token_auth(auth: dict[str, Any], source: str) -> dict[str, Any]:
+    """Validate bearer-token authentication.
+
+    Args:
+        auth: Authentication dictionary
+        source: Source parameter name for error messages
+
+    Returns:
+        Validated bearer-token authentication dictionary
+
+    Raises:
+        click.ClickException: If bearer-token structure is invalid
+    """
+    token = auth.get("token")
+    if isinstance(token, str) and token.strip():
+        return {"type": "bearer-token", "token": token}
+    headers = auth.get("headers")
+    normalized_headers = _validate_headers_mapping(
+        headers, source=source, context="bearer-token authentication"
+    )
+    return {"type": "bearer-token", "headers": normalized_headers}
+
+
+def _validate_api_key_auth(auth: dict[str, Any], source: str) -> dict[str, Any]:
+    """Validate api-key authentication.
+
+    Args:
+        auth: Authentication dictionary
+        source: Source parameter name for error messages
+
+    Returns:
+        Validated api-key authentication dictionary
+
+    Raises:
+        click.ClickException: If api-key structure is invalid
+    """
+    headers = auth.get("headers")
+    if headers is not None:
+        normalized_headers = _validate_headers_mapping(
+            headers, source=source, context="api-key authentication"
+        )
+        return {"type": "api-key", "headers": normalized_headers}
+
+    key = auth.get("key")
+    value = auth.get("value")
+    if not isinstance(key, str) or not key.strip():
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "api-key authentication requires a non-empty 'key'.",
+            )
+        )
+    if not isinstance(value, str) or not value.strip():
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "api-key authentication requires a non-empty 'value'.",
+            )
+        )
+    return {"type": "api-key", "key": key, "value": value}
+
+
+def _validate_custom_header_auth(auth: dict[str, Any], source: str) -> dict[str, Any]:
+    """Validate custom-header authentication.
+
+    Args:
+        auth: Authentication dictionary
+        source: Source parameter name for error messages
+
+    Returns:
+        Validated custom-header authentication dictionary
+
+    Raises:
+        click.ClickException: If custom-header structure is invalid
+    """
+    headers = auth.get("headers")
+    normalized_headers = _validate_headers_mapping(
+        headers, source=source, context="custom-header authentication"
+    )
+    return {"type": "custom-header", "headers": normalized_headers}
+
+
+def validate_mcp_auth_structure(auth: Any, *, source: str = "--auth") -> dict[str, Any]:
+    """Validate MCP authentication structure for CLI commands.
+
+    Validates authentication objects according to the MCP schema, supporting:
+    - no-auth: No authentication required
+    - bearer-token: Bearer token via 'token' field or 'headers'
+    - api-key: API key via 'key'/'value' fields or 'headers'
+    - custom-header: Custom headers via 'headers' object
+
+    Args:
+        auth: Authentication value to validate (expected to be a dict or None)
+        source: Source parameter name for error messages (default: "--auth")
+
+    Returns:
+        Validated authentication dictionary, or empty dict if auth is None
+
+    Raises:
+        click.ClickException: If auth structure is invalid or type is unsupported
+
+    Examples:
+        >>> validate_mcp_auth_structure(None)
+        {}
+
+        >>> validate_mcp_auth_structure({"type": "no-auth"})
+        {'type': 'no-auth'}
+
+        >>> validate_mcp_auth_structure({"type": "bearer-token", "token": "abc123"})
+        {'type': 'bearer-token', 'token': 'abc123'}
+
+    Schema Reference:
+        See docs/reference/schemas/mcps.md - Authentication Types
+        - Required field: 'type' (string, one of: no-auth, bearer-token, api-key, custom-header)
+        - Additional fields depend on type
+    """
+    if auth is None:
+        return {}
+
+    if not isinstance(auth, dict):
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "Expected a JSON object representing MCP authentication.",
+            )
+        )
+
+    raw_type = auth.get("type")
+    if not isinstance(raw_type, str) or not raw_type.strip():
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "Authentication objects must include a non-empty 'type' field.",
+            )
+        )
+
+    auth_type = raw_type.strip()
+
+    # Dispatch to type-specific validators
+    if auth_type == "no-auth":
+        return {"type": "no-auth"}
+    if auth_type == "bearer-token":
+        return _validate_bearer_token_auth(auth, source)
+    if auth_type == "api-key":
+        return _validate_api_key_auth(auth, source)
+    if auth_type == "custom-header":
+        return _validate_custom_header_auth(auth, source)
+
+    # Unknown type
+    raise click.ClickException(
+        format_validation_error(
+            f"Invalid {source} value",
+            f"Unsupported authentication type '{auth_type}'. "
+            f"Supported types: no-auth, bearer-token, api-key, custom-header",
+        )
+    )

glaip_sdk/cli/parsers/__init__.py

@@ -0,0 +1,9 @@
+"""CLI input parsers.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+from glaip_sdk.cli.parsers.json_input import parse_json_input
+
+__all__ = ["parse_json_input"]

glaip_sdk/cli/parsers/json_input.py

@@ -0,0 +1,140 @@
+"""JSON input parser for CLI options.
+
+Handles both inline JSON strings and @file references.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import click
+
+
+def _format_file_error(
+    prefix: str, file_path_str: str, resolved_path: Path, *, detail: str | None = None
+) -> str:
+    """Format a file-related error message with path context.
+
+    Args:
+        prefix: Main error message
+        file_path_str: Original file path string provided by user
+        resolved_path: Resolved absolute path
+        detail: Optional additional detail to append
+
+    Returns:
+        Formatted error message string with file path context
+
+    Examples:
+        >>> from pathlib import Path
+        >>> _format_file_error("File not found", "config.json", Path("/abs/config.json"))
+        'File not found: config.json\\nResolved path: /abs/config.json'
+    """
+    parts = [f"{prefix}: {file_path_str}", f"Resolved path: {resolved_path}"]
+    if detail:
+        parts.append(detail)
+    return "\n".join(parts)
+
+
+def _parse_json_from_file(file_path_str: str) -> Any:
+    """Parse JSON from a file path.
+
+    Args:
+        file_path_str: Path to the JSON file (without @ prefix).
+
+    Returns:
+        Parsed dictionary from file.
+
+    Raises:
+        click.ClickException: If file not found, not readable, empty, or invalid JSON.
+    """
+    # Resolve relative paths against CWD
+    file_path = Path(file_path_str)
+    if not file_path.is_absolute():
+        file_path = Path.cwd() / file_path
+
+    # Check if file exists and is a regular file
+    if not file_path.is_file():
+        raise click.ClickException(
+            _format_file_error("File not found or not a file", file_path_str, file_path)
+        )
+
+    # Check if file is readable
+    if not os.access(file_path, os.R_OK):
+        raise click.ClickException(
+            _format_file_error(
+                "File not readable (permission denied)", file_path_str, file_path
+            )
+        )
+
+    # Read file content
+    try:
+        content = file_path.read_text(encoding="utf-8")
+    except Exception as e:
+        raise click.ClickException(
+            _format_file_error(
+                "Error reading file", file_path_str, file_path, detail=f"Error: {e}"
+            )
+        )
+
+    # Check for empty content
+    if not content.strip():
+        raise click.ClickException(
+            _format_file_error("File is empty", file_path_str, file_path)
+        )
+
+    # Parse JSON from file content
+    try:
+        return json.loads(content)
+    except json.JSONDecodeError as e:
+        raise click.ClickException(
+            _format_file_error(
+                "Invalid JSON in file",
+                file_path_str,
+                file_path,
+                detail=f"Error: {e.msg} at line {e.lineno}, column {e.colno}",
+            )
+        )
+
+
+def parse_json_input(value: str | None) -> Any:
+    """Parse JSON input from inline string or file reference.
+
+    Args:
+        value: JSON string or @file reference. If None, returns None.
+
+    Returns:
+        Parsed JSON value (dict, list, str, int, float, bool, None) or None if value is None.
+
+    Raises:
+        click.ClickException: If file not found, not readable, empty, or invalid JSON.
+
+    Examples:
+        >>> parse_json_input('{"key": "value"}')
+        {'key': 'value'}
+
+        >>> parse_json_input('@/path/to/config.json')
+        # Returns content of config.json parsed as JSON
+
+        >>> parse_json_input(None)
+        None
+    """
+    if value is None:
+        return None
+
+    # Check if value is a file reference (strip whitespace first)
+    trimmed = value.strip()
+    if trimmed.startswith("@"):
+        return _parse_json_from_file(trimmed[1:])
+
+    # Parse inline JSON
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError as e:
+        raise click.ClickException(
+            f"Invalid JSON in inline value\n"
+            f"Error: {e.msg} at line {e.lineno}, column {e.colno}"
+        )

glaip_sdk/client/mcps.py

@@ -57,7 +57,7 @@ class MCPClient(BaseClient):
     def create_mcp(
         self,
         name: str,
-        description: str,
+        description: str | None = None,
         config: dict[str, Any] | None = None,
         **kwargs,
     ) -> MCP:
@@ -108,7 +108,7 @@ class MCPClient(BaseClient):
     def _build_create_payload(
         self,
         name: str,
-        description: str,
+        description: str | None = None,
         transport: str = DEFAULT_MCP_TRANSPORT,
         config: dict[str, Any] | None = None,
         **kwargs,
@@ -122,7 +122,7 @@ class MCPClient(BaseClient):
 
         Args:
             name: MCP name
-            description: MCP description
+            description: MCP description (optional)
             transport: MCP transport protocol (defaults to stdio)
             config: MCP configuration dictionary
             **kwargs: Additional parameters

{glaip_sdk-0.0.11.dist-info → glaip_sdk-0.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: glaip-sdk
-Version: 0.0.11
+Version: 0.0.13
 Summary: Python SDK for GL AIP (GDP Labs AI Agent Package) - Simplified CLI Design
 License: MIT
 Author: Raymond Christopher

{glaip_sdk-0.0.11.dist-info → glaip_sdk-0.0.13.dist-info}/RECORD

@@ -7,12 +7,15 @@ glaip_sdk/cli/auth.py,sha256=eYdtGmJ3XgiO96hq_69GF6b3W-aRWZrDQ-6bHuaRX4M,13517
 glaip_sdk/cli/commands/__init__.py,sha256=x0CZlZbZHoHvuzfoTWIyEch6WmNnbPzxajrox6riYp0,173
 glaip_sdk/cli/commands/agents.py,sha256=97dzowjHgk5knyHuI-0z2ojvqNlkebNN1-ikGEoS5sc,40623
 glaip_sdk/cli/commands/configure.py,sha256=eRDzsaKV4fl2lJt8ieS4g2-xRnaa02eAAPW8xBf-tqA,7507
-glaip_sdk/cli/commands/mcps.py,sha256=a2p8KfPYv4YaC9qiC7LEyh8oPsbLAwXv4dsnwxZ_juI,19752
+glaip_sdk/cli/commands/mcps.py,sha256=ENhasfSupmCSKs-Ycg-M9Gy-58Y55SMIQzeg3fBJj48,28186
 glaip_sdk/cli/commands/models.py,sha256=Ra3-50BPScNs0Q-j4b7U4iK0hNooucEyVgHpQ11-pt8,1700
 glaip_sdk/cli/commands/tools.py,sha256=MOM9Db3HGL1stF-WvL5cZXjw-iZo2qc-oyKQHy6VwIM,18690
 glaip_sdk/cli/display.py,sha256=jE20swoRKzpYUmc0jgbeonaXKeE9x95hfjWAEdnBYRc,8727
 glaip_sdk/cli/io.py,sha256=GPkw3pQMLBGoD5GH-KlbKpNRlVWFZOXHE17F7V3kQsI,3343
 glaip_sdk/cli/main.py,sha256=3Bl8u9t1MekzaNrAZqsx4TukbzzFdi6Wss6jvTDos00,12930
+glaip_sdk/cli/mcp_validators.py,sha256=PEJRzb7ogRkwNJwJK9k5Xmb8hvoQ58L2Qywqd_3Wayo,10125
+glaip_sdk/cli/parsers/__init__.py,sha256=Ycd4HDfYmA7GUGFt0ndBPBo5uTbv15XsXnYUj-a89ug,183
+glaip_sdk/cli/parsers/json_input.py,sha256=iISa31ZsDNYWfCVRy0cifRIg2gjnhI-XtdDLB-UOshg,4039
 glaip_sdk/cli/resolution.py,sha256=BOw2NchReLKewAwBAZLWw_3_bI7u3tfzQEO7kQbIiGE,2067
 glaip_sdk/cli/slash/__init__.py,sha256=Vdv6Y8bu-pA8dxDlyP4XrhudBPivztUozhLAz9vaLig,682
 glaip_sdk/cli/slash/agent_session.py,sha256=pDOwGXNHuyJIulrGYu1pacyF3oxHWeDQY-Uv92h2qVg,6859
@@ -25,7 +28,7 @@ glaip_sdk/client/__init__.py,sha256=nYLXfBVTTWwKjP0e63iumPYO4k5FifwWaELQPaPIKIg,
 glaip_sdk/client/agents.py,sha256=FSKubF40wptMNIheC3_iawiX2CRbhTcNLFiz4qkPC6k,34659
 glaip_sdk/client/base.py,sha256=O3dv3I7PqY91gH1FehBMRZcSXjwimfeBcJuiXidDmqw,13700
 glaip_sdk/client/main.py,sha256=LlvYHP7-Hy7Eq1ep1kfk337K-Oue5SdKWJpqYfX9eXY,7993
-glaip_sdk/client/mcps.py,sha256=yxwrAtztElYDEGhp2EHRpeYUxNsOlTLTqtw9jSKJmcI,8936
+glaip_sdk/client/mcps.py,sha256=-O-I15qjbwfSA69mouHY6g5_qgPWC4rM98VJLpOkh1A,8975
 glaip_sdk/client/tools.py,sha256=n8DIiOOf1YU_j9JK3Bx2-rDnkpckPi0MI9Ok2s1kwa4,16634
 glaip_sdk/client/validators.py,sha256=NtPsWjQLjj25LiUnmR-WuS8lL5p4MVRaYT9UVRmj9bo,8809
 glaip_sdk/config/constants.py,sha256=ysEobMiXlLZGIOEaqTdHpPF8kmg5nbLn7BIcBvTCuHM,819
@@ -55,7 +58,7 @@ glaip_sdk/utils/rich_utils.py,sha256=-Ij-1bIJvnVAi6DrfftchIlMcvOTjVmSE0Qqax0EY_s
 glaip_sdk/utils/run_renderer.py,sha256=d_VMI6LbvHPUUeRmGqh5wK_lHqDEIAcym2iqpbtDad0,1365
 glaip_sdk/utils/serialization.py,sha256=T1yt_8G2DCFpcxx7XnqFl5slksRXfBCUuLQJTreGYEQ,11806
 glaip_sdk/utils/validation.py,sha256=QNORcdyvuliEs4EH2_mkDgmoyT9utgl7YNhaf45SEf8,6992
-glaip_sdk-0.0.11.dist-info/METADATA,sha256=Z8hxLQAn8fWQtisQyZAi6QgOCSxDpEWw4gLbTBMDrxU,4984
-glaip_sdk-0.0.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-glaip_sdk-0.0.11.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
-glaip_sdk-0.0.11.dist-info/RECORD,,
+glaip_sdk-0.0.13.dist-info/METADATA,sha256=Kv1zs8YO3gQigogChDeITrmnA7UggqkM_qBFnkAAi-k,4984
+glaip_sdk-0.0.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+glaip_sdk-0.0.13.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
+glaip_sdk-0.0.13.dist-info/RECORD,,