napistu 0.2.5.dev6__py3-none-any.whl → 0.3.1__py3-none-any.whl

napistu/mcp/__main__.py

@@ -1,4 +1,3 @@
-# src/napistu/mcp/__main__.py
 """
 MCP (Model Context Protocol) Server CLI for Napistu.
 """
@@ -16,6 +15,15 @@ from napistu.mcp.client import (
     list_server_resources,
     read_server_resource,
 )
+from napistu.mcp.config import (
+    validate_server_config_flags,
+    validate_client_config_flags,
+    server_config_options,
+    client_config_options,
+    local_server_config,
+    local_client_config,
+    production_client_config,
+)
 
 logger = logging.getLogger(napistu.__name__)
 click_logging.basic_config(logger)
@@ -35,157 +43,205 @@ def server():
 
 @server.command(name="start")
 @click.option(
-    "--profile", type=click.Choice(["local", "remote", "full"]), default="remote"
+    "--profile", type=click.Choice(["execution", "docs", "full"]), default="docs"
 )
-@click.option("--host", type=str, default="127.0.0.1")
-@click.option("--port", type=int, default=8765)
-@click.option("--server-name", type=str)
+@server_config_options
 @click_logging.simple_verbosity_option(logger)
-def start_server(profile, host, port, server_name):
+def start_server(profile, production, local, host, port, server_name):
     """Start an MCP server with the specified profile."""
-    start_mcp_server(profile, host, port, server_name)
+    try:
+        config = validate_server_config_flags(
+            local, production, host, port, server_name
+        )
+
+        click.echo("Starting server with configuration:")
+        click.echo(f"  Profile: {profile}")
+        click.echo(f"  Host: {config.host}")
+        click.echo(f"  Port: {config.port}")
+        click.echo(f"  Server Name: {config.server_name}")
+
+        start_mcp_server(profile, config)
+
+    except click.BadParameter as e:
+        raise click.ClickException(str(e))
 
 
 @server.command(name="local")
-@click.option("--server-name", type=str, default="napistu-local")
 @click_logging.simple_verbosity_option(logger)
-def start_local(server_name):
+def start_local():
     """Start a local MCP server optimized for function execution."""
-    start_mcp_server("local", "127.0.0.1", 8765, server_name)
+    config = local_server_config()
+    click.echo("Starting local development server (execution profile)")
+    click.echo(f"  Host: {config.host}")
+    click.echo(f"  Port: {config.port}")
+    click.echo(f"  Server Name: {config.server_name}")
+
+    start_mcp_server("execution", config)
 
 
 @server.command(name="full")
-@click.option("--server-name", type=str, default="napistu-full")
 @click_logging.simple_verbosity_option(logger)
-def start_full(server_name):
+def start_full():
     """Start a full MCP server with all components enabled (local debugging)."""
-    start_mcp_server("full", "127.0.0.1", 8765, server_name)
+    config = local_server_config()
+    # Override server name for full profile
+    config.server_name = "napistu-full"
+
+    click.echo("Starting full development server (all components)")
+    click.echo(f"  Host: {config.host}")
+    click.echo(f"  Port: {config.port}")
+    click.echo(f"  Server Name: {config.server_name}")
+
+    start_mcp_server("full", config)
 
 
 @cli.command()
-@click.option("--url", default="http://127.0.0.1:8765", help="Server URL")
+@client_config_options
 @click_logging.simple_verbosity_option(logger)
-def health(url):
+def health(production, local, host, port, https):
     """Quick health check of MCP server."""
 
     async def run_health_check():
-        print("🏥 Napistu MCP Server Health Check")
-        print("=" * 40)
-        print(f"Server URL: {url}")
-        print()
+        try:
+            config = validate_client_config_flags(local, production, host, port, https)
+
+            print("🏥 Napistu MCP Server Health Check")
+            print("=" * 40)
+            print(f"Server URL: {config.base_url}")
+            print()
 
-        health = await check_server_health(server_url=url)
-        print_health_status(health)
+            health = await check_server_health(config)
+            print_health_status(health)
+
+        except click.BadParameter as e:
+            raise click.ClickException(str(e))
 
     asyncio.run(run_health_check())
 
 
 @cli.command()
-@click.option("--url", default="http://127.0.0.1:8765", help="Server URL")
+@client_config_options
 @click_logging.simple_verbosity_option(logger)
-def resources(url):
+def resources(production, local, host, port, https):
     """List all available resources on the MCP server."""
 
     async def run_list_resources():
-        print("📋 Napistu MCP Server Resources")
-        print("=" * 40)
-        print(f"Server URL: {url}")
-        print()
-
-        resources = await list_server_resources(server_url=url)
-
-        if resources:
-            print(f"Found {len(resources)} resources:")
-            for resource in resources:
-                print(f"  📄 {resource.uri}")
-                if resource.name != resource.uri:
-                    print(f"      Name: {resource.name}")
-                if hasattr(resource, "description") and resource.description:
-                    print(f"      Description: {resource.description}")
-                print()
-        else:
-            print("❌ Could not retrieve resources")
+        try:
+            config = validate_client_config_flags(local, production, host, port, https)
+
+            print("📋 Napistu MCP Server Resources")
+            print("=" * 40)
+            print(f"Server URL: {config.base_url}")
+            print()
+
+            resources = await list_server_resources(config)
+
+            if resources:
+                print(f"Found {len(resources)} resources:")
+                for resource in resources:
+                    print(f"  📄 {resource.uri}")
+                    if resource.name != resource.uri:
+                        print(f"      Name: {resource.name}")
+                    if hasattr(resource, "description") and resource.description:
+                        print(f"      Description: {resource.description}")
+                    print()
+            else:
+                print("❌ Could not retrieve resources")
+
+        except click.BadParameter as e:
+            raise click.ClickException(str(e))
 
     asyncio.run(run_list_resources())
 
 
 @cli.command()
 @click.argument("resource_uri")
-@click.option("--url", default="http://127.0.0.1:8765", help="Server URL")
+@client_config_options
 @click.option(
     "--output", type=click.File("w"), default="-", help="Output file (default: stdout)"
 )
 @click_logging.simple_verbosity_option(logger)
-def read(resource_uri, url, output):
+def read(resource_uri, production, local, host, port, https, output):
     """Read a specific resource from the MCP server."""
 
     async def run_read_resource():
-        print(
-            f"📖 Reading Resource: {resource_uri}",
-            file=output if output.name != "<stdout>" else None,
-        )
-        print(f"Server URL: {url}", file=output if output.name != "<stdout>" else None)
-        print("=" * 50, file=output if output.name != "<stdout>" else None)
+        try:
+            config = validate_client_config_flags(local, production, host, port, https)
 
-        content = await read_server_resource(resource_uri, server_url=url)
-
-        if content:
-            print(content, file=output)
-        else:
             print(
-                "❌ Could not read resource",
+                f"📖 Reading Resource: {resource_uri}",
+                file=output if output.name != "<stdout>" else None,
+            )
+            print(
+                f"Server URL: {config.base_url}",
                 file=output if output.name != "<stdout>" else None,
             )
+            print("=" * 50, file=output if output.name != "<stdout>" else None)
+
+            content = await read_server_resource(resource_uri, config)
+
+            if content:
+                print(content, file=output)
+            else:
+                print(
+                    "❌ Could not read resource",
+                    file=output if output.name != "<stdout>" else None,
+                )
+
+        except click.BadParameter as e:
+            raise click.ClickException(str(e))
 
     asyncio.run(run_read_resource())
 
 
 @cli.command()
-@click.option("--local-url", default="http://127.0.0.1:8765", help="Local server URL")
-@click.option("--remote-url", required=True, help="Remote server URL")
 @click_logging.simple_verbosity_option(logger)
-def compare(local_url, remote_url):
-    """Compare health between local and remote servers."""
+def compare():
+    """Compare health between local development and production servers."""
 
     async def run_comparison():
-        print("🔍 Local vs Remote Server Comparison")
+
+        local_config = local_client_config()
+        production_config = production_client_config()
+
+        print("🔍 Local vs Production Server Comparison")
         print("=" * 50)
 
-        print(f"\n📍 Local Server: {local_url}")
-        local_health = await check_server_health(server_url=local_url)
+        print(f"\n📍 Local Server: {local_config.base_url}")
+        local_health = await check_server_health(local_config)
         print_health_status(local_health)
 
-        print(f"\n🌐 Remote Server: {remote_url}")
-        remote_health = await check_server_health(server_url=remote_url)
-        print_health_status(remote_health)
+        print(f"\n🌐 Production Server: {production_config.base_url}")
+        production_health = await check_server_health(production_config)
+        print_health_status(production_health)
 
         # Compare results
         print("\n📊 Comparison Summary:")
-        if local_health and remote_health:
+        if local_health and production_health:
             local_components = local_health.get("components", {})
-            remote_components = remote_health.get("components", {})
+            production_components = production_health.get("components", {})
 
             all_components = set(local_components.keys()) | set(
-                remote_components.keys()
+                production_components.keys()
             )
 
             for component in sorted(all_components):
                 local_status = local_components.get(component, {}).get(
                     "status", "missing"
                 )
-                remote_status = remote_components.get(component, {}).get(
+                production_status = production_components.get(component, {}).get(
                     "status", "missing"
                 )
 
-                if local_status == remote_status == "healthy":
+                if local_status == production_status == "healthy":
                     icon = "✅"
-                elif local_status != remote_status:
+                elif local_status != production_status:
                     icon = "⚠️ "
                 else:
                     icon = "❌"
 
                 print(
-                    f"  {icon} {component}: Local={local_status}, Remote={remote_status}"
+                    f"  {icon} {component}: Local={local_status}, Production={production_status}"
                 )
         else:
             print("  ❌ Cannot compare - one or both servers unreachable")

napistu/mcp/client.py

@@ -1,4 +1,3 @@
-# src/napistu/mcp/client.py
 """
 MCP client for testing and interacting with Napistu MCP servers.
 """
@@ -8,20 +7,19 @@ import logging
 from typing import Optional, Dict, Any, Mapping
 
 from fastmcp import Client
+from napistu.mcp.config import MCPClientConfig
 
 logger = logging.getLogger(__name__)
 
 
-async def check_server_health(
-    server_url: str = "http://127.0.0.1:8765",
-) -> Optional[Dict[str, Any]]:
+async def check_server_health(config: MCPClientConfig) -> Optional[Dict[str, Any]]:
     """
     Health check using FastMCP client.
 
     Parameters
     ----------
-    server_url : str, optional
-        Server URL for HTTP transport. Defaults to 'http://127.0.0.1:8765'.
+    config : MCPClientConfig
+        Client configuration object with validated settings.
 
     Returns
     -------
@@ -37,13 +35,10 @@ async def check_server_health(
             - components : Dict[str, Dict[str, str]]
                 Status of each component ('healthy', 'inactive', or 'unavailable')
     """
-
     try:
-        # FastMCP streamable-http requires the /mcp path
-        mcp_url = server_url.rstrip("/") + "/mcp"
-        logger.info(f"Connecting to MCP server at: {mcp_url}")
+        logger.info(f"Connecting to MCP server at: {config.mcp_url}")
 
-        client = Client(mcp_url)
+        client = Client(config.mcp_url)
 
         async with client:
             logger.info("✅ FastMCP client connected")
@@ -137,16 +132,14 @@ def print_health_status(health: Optional[Mapping[str, Any]]) -> None:
         print(f"Version: {health['version']}")
 
 
-async def list_server_resources(
-    server_url: str = "http://127.0.0.1:8765",
-) -> Optional[list]:
+async def list_server_resources(config: MCPClientConfig) -> Optional[list]:
     """
     List all available resources on the MCP server.
 
     Parameters
     ----------
-    server_url : str, optional
-        Server URL for HTTP transport. Defaults to 'http://127.0.0.1:8765'.
+    config : MCPClientConfig
+        Client configuration object with validated settings.
 
     Returns
     -------
@@ -154,10 +147,9 @@ async def list_server_resources(
         List of available resources, or None if failed.
     """
     try:
-        mcp_url = server_url.rstrip("/") + "/mcp"
-        logger.info(f"Listing resources from: {mcp_url}")
+        logger.info(f"Listing resources from: {config.mcp_url}")
 
-        client = Client(mcp_url)
+        client = Client(config.mcp_url)
 
         async with client:
             resources = await client.list_resources()
@@ -170,7 +162,7 @@ async def list_server_resources(
 
 
 async def read_server_resource(
-    resource_uri: str, server_url: str = "http://127.0.0.1:8765"
+    resource_uri: str, config: MCPClientConfig
 ) -> Optional[str]:
     """
     Read a specific resource from the MCP server.
@@ -179,8 +171,8 @@ async def read_server_resource(
     ----------
     resource_uri : str
         URI of the resource to read (e.g., 'napistu://health')
-    server_url : str, optional
-        Server URL for HTTP transport. Defaults to 'http://127.0.0.1:8765'.
+    config : MCPClientConfig
+        Client configuration object with validated settings.
 
     Returns
     -------
@@ -188,10 +180,9 @@ async def read_server_resource(
         Resource content as text, or None if failed.
     """
     try:
-        mcp_url = server_url.rstrip("/") + "/mcp"
-        logger.info(f"Reading resource {resource_uri} from: {mcp_url}")
+        logger.info(f"Reading resource {resource_uri} from: {config.mcp_url}")
 
-        client = Client(mcp_url)
+        client = Client(config.mcp_url)
 
         async with client:
             result = await client.read_resource(resource_uri)