fastmcp 2.10.2__py3-none-any.whl → 2.10.3__py3-none-any.whl

fastmcp/cli/cli.py

@@ -1,6 +1,5 @@
-"""FastMCP CLI tools."""
+"""FastMCP CLI tools using Cyclopts."""
 
-import asyncio
 import importlib.metadata
 import importlib.util
 import os
@@ -8,18 +7,17 @@ import platform
 import subprocess
 import sys
 from pathlib import Path
-from typing import Annotated
+from typing import Annotated, Literal
 
-import dotenv
-import typer
+import cyclopts
+import pyperclip
 from pydantic import TypeAdapter
 from rich.console import Console
 from rich.table import Table
-from typer import Context, Exit
 
 import fastmcp
-from fastmcp.cli import claude
 from fastmcp.cli import run as run_module
+from fastmcp.cli.install import install_app
 from fastmcp.server.server import FastMCP
 from fastmcp.utilities.inspect import FastMCPInfo, inspect_fastmcp
 from fastmcp.utilities.logging import get_logger
@@ -27,11 +25,10 @@ from fastmcp.utilities.logging import get_logger
 logger = get_logger("cli")
 console = Console()
 
-app = typer.Typer(
+app = cyclopts.App(
     name="fastmcp",
-    help="FastMCP CLI",
-    add_completion=False,
-    no_args_is_help=True,  # Show help if no args provided
+    help="FastMCP 2.0 - The fast, Pythonic way to build MCP servers and clients.",
+    version=fastmcp.__version__,
 )
 
 
@@ -88,11 +85,19 @@ def _build_uv_command(
     return cmd
 
 
-@app.command()
-def version(ctx: Context):
-    if ctx.resilient_parsing:
-        return
-
+@app.command
+def version(
+    *,
+    copy: Annotated[
+        bool,
+        cyclopts.Parameter(
+            "--copy",
+            help="Copy version information to clipboard",
+            negative=False,
+        ),
+    ] = False,
+):
+    """Display version information and platform details."""
     info = {
         "FastMCP version": fastmcp.__version__,
         "MCP version": importlib.metadata.version("mcp"),
@@ -106,58 +111,64 @@ def version(ctx: Context):
     g.add_column(style="cyan", justify="right")
     for k, v in info.items():
         g.add_row(k + ":", str(v).replace("\n", " "))
-    console.print(g)
 
-    raise Exit()
+    if copy:
+        # Use Rich's plain text rendering for copying
+        plain_console = Console(file=None, force_terminal=False, legacy_windows=False)
+        with plain_console.capture() as capture:
+            plain_console.print(g)
+        pyperclip.copy(capture.get())
+        console.print("[green]✓[/green] Version information copied to clipboard")
+    else:
+        console.print(g)
 
 
-@app.command()
+@app.command
 def dev(
-    server_spec: str = typer.Argument(
-        ...,
-        help="Python file to run, optionally with :object suffix",
-    ),
+    server_spec: str,
+    *,
     with_editable: Annotated[
         Path | None,
-        typer.Option(
-            "--with-editable",
-            "-e",
+        cyclopts.Parameter(
+            name=["--with-editable", "-e"],
             help="Directory containing pyproject.toml to install in editable mode",
-            exists=True,
-            file_okay=False,
-            resolve_path=True,
         ),
     ] = None,
     with_packages: Annotated[
         list[str],
-        typer.Option(
+        cyclopts.Parameter(
             "--with",
             help="Additional packages to install",
+            negative=False,
         ),
     ] = [],
     inspector_version: Annotated[
         str | None,
-        typer.Option(
+        cyclopts.Parameter(
             "--inspector-version",
             help="Version of the MCP Inspector to use",
         ),
     ] = None,
     ui_port: Annotated[
         int | None,
-        typer.Option(
+        cyclopts.Parameter(
             "--ui-port",
             help="Port for the MCP Inspector UI",
         ),
     ] = None,
     server_port: Annotated[
         int | None,
-        typer.Option(
+        cyclopts.Parameter(
             "--server-port",
             help="Port for the MCP Inspector Proxy server",
         ),
     ] = None,
 ) -> None:
-    """Run a MCP server with the MCP Inspector."""
+    """Run an MCP server with the MCP Inspector for development.
+
+    Args:
+        server_spec: Python file to run, optionally with :object suffix
+    """
     file, server_object = run_module.parse_file_path(server_spec)
 
     logger.debug(
@@ -230,66 +241,69 @@ def dev(
         sys.exit(1)
 
 
-@app.command(context_settings={"allow_extra_args": True})
+@app.command
 def run(
-    ctx: typer.Context,
-    server_spec: str = typer.Argument(
-        ...,
-        help="Python file, object specification (file:obj), or URL",
-    ),
+    server_spec: str,
+    *,
     transport: Annotated[
-        str | None,
-        typer.Option(
-            "--transport",
-            "-t",
-            help="Transport protocol to use (stdio, http, or sse)",
+        Literal["stdio", "http", "sse"] | None,
+        cyclopts.Parameter(
+            name=["--transport", "-t"],
+            help="Transport protocol to use",
         ),
     ] = None,
     host: Annotated[
         str | None,
-        typer.Option(
+        cyclopts.Parameter(
             "--host",
             help="Host to bind to when using http transport (default: 127.0.0.1)",
         ),
     ] = None,
     port: Annotated[
         int | None,
-        typer.Option(
-            "--port",
-            "-p",
+        cyclopts.Parameter(
+            name=["--port", "-p"],
             help="Port to bind to when using http transport (default: 8000)",
         ),
     ] = None,
-    log_level: Annotated[
+    path: Annotated[
         str | None,
-        typer.Option(
-            "--log-level",
-            "-l",
-            help="Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+        cyclopts.Parameter(
+            "--path",
+            help="The route path for the server (default: /mcp/ for http transport, /sse/ for sse transport)",
+        ),
+    ] = None,
+    log_level: Annotated[
+        Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None,
+        cyclopts.Parameter(
+            name=["--log-level", "-l"],
+            help="Log level",
         ),
     ] = None,
     no_banner: Annotated[
         bool,
-        typer.Option(
+        cyclopts.Parameter(
             "--no-banner",
             help="Don't show the server banner",
+            negative=False,
         ),
     ] = False,
 ) -> None:
-    """Run a MCP server or connect to a remote one.
+    """Run an MCP server or connect to a remote one.
 
     The server can be specified in three ways:
-    1. Module approach: server.py - runs the module directly, looking for an object named mcp/server/app.\n
-    2. Import approach: server.py:app - imports and runs the specified server object.\n
-    3. URL approach: http://server-url - connects to a remote server and creates a proxy.\n\n
-
-    Note: This command runs the server directly. You are responsible for ensuring
-    all dependencies are available.
+    1. Module approach: server.py - runs the module directly, looking for an object named 'mcp', 'server', or 'app'
+    2. Import approach: server.py:app - imports and runs the specified server object
+    3. URL approach: http://server-url - connects to a remote server and creates a proxy
 
     Server arguments can be passed after -- :
     fastmcp run server.py -- --config config.json --debug
+
+    Args:
+        server_spec: Python file, object specification (file:obj), or URL
     """
-    server_args = ctx.args  # extra args after --
+    # TODO: Handle server_args from extra context
+    server_args = []  # Will need to handle this with Cyclopts context
 
     logger.debug(
         "Running server or client",
@@ -298,6 +312,7 @@ def run(
             "transport": transport,
             "host": host,
             "port": port,
+            "path": path,
             "log_level": log_level,
             "server_args": server_args,
         },
@@ -309,6 +324,7 @@ def run(
             transport=transport,
             host=host,
             port=port,
+            path=path,
             log_level=log_level,
             server_args=server_args,
             show_banner=not no_banner,
@@ -324,166 +340,33 @@ def run(
         sys.exit(1)
 
 
-@app.command()
-def install(
-    server_spec: str = typer.Argument(
-        ...,
-        help="Python file to run, optionally with :object suffix",
-    ),
-    server_name: Annotated[
-        str | None,
-        typer.Option(
-            "--name",
-            "-n",
-            help="Custom name for the server (defaults to server's name attribute or"
-            " file name)",
-        ),
-    ] = None,
-    with_editable: Annotated[
-        Path | None,
-        typer.Option(
-            "--with-editable",
-            "-e",
-            help="Directory containing pyproject.toml to install in editable mode",
-            exists=True,
-            file_okay=False,
-            resolve_path=True,
-        ),
-    ] = None,
-    with_packages: Annotated[
-        list[str],
-        typer.Option(
-            "--with",
-            help="Additional packages to install",
-        ),
-    ] = [],
-    env_vars: Annotated[
-        list[str],
-        typer.Option(
-            "--env-var",
-            "-v",
-            help="Environment variables in KEY=VALUE format",
-        ),
-    ] = [],
-    env_file: Annotated[
-        Path | None,
-        typer.Option(
-            "--env-file",
-            "-f",
-            help="Load environment variables from a .env file",
-            exists=True,
-            file_okay=True,
-            dir_okay=False,
-            resolve_path=True,
-        ),
-    ] = None,
-) -> None:
-    """Install a MCP server in the Claude desktop app.
-
-    Environment variables are preserved once added and only updated if new values
-    are explicitly provided.
-    """
-    file, server_object = run_module.parse_file_path(server_spec)
-
-    logger.debug(
-        "Installing server",
-        extra={
-            "file": str(file),
-            "server_name": server_name,
-            "server_object": server_object,
-            "with_editable": str(with_editable) if with_editable else None,
-            "with_packages": with_packages,
-        },
-    )
-
-    if not claude.get_claude_config_path():
-        logger.error("Claude app not found")
-        sys.exit(1)
-
-    # Try to import server to get its name, but fall back to file name if dependencies
-    # missing
-    name = server_name
-    server = None
-    if not name:
-        try:
-            server = run_module.import_server(file, server_object)
-            name = server.name
-        except (ImportError, ModuleNotFoundError) as e:
-            logger.debug(
-                "Could not import server (likely missing dependencies), using file"
-                " name",
-                extra={"error": str(e)},
-            )
-            name = file.stem
-
-    # Get server dependencies if available
-    server_dependencies = getattr(server, "dependencies", []) if server else []
-    if server_dependencies:
-        with_packages = list(set(with_packages + server_dependencies))
-
-    # Process environment variables if provided
-    env_dict: dict[str, str] | None = None
-    if env_file or env_vars:
-        env_dict = {}
-        # Load from .env file if specified
-        if env_file:
-            try:
-                env_dict |= {
-                    k: v
-                    for k, v in dotenv.dotenv_values(env_file).items()
-                    if v is not None
-                }
-            except Exception as e:
-                logger.error(f"Failed to load .env file: {e}")
-                sys.exit(1)
-
-        # Add command line environment variables
-        for env_var in env_vars:
-            key, value = _parse_env_var(env_var)
-            env_dict[key] = value
-
-    if claude.update_claude_config(
-        server_spec,
-        name,
-        with_editable=with_editable,
-        with_packages=with_packages,
-        env_vars=env_dict,
-    ):
-        logger.info(f"Successfully installed {name} in Claude app")
-    else:
-        logger.error(f"Failed to install {name} in Claude app")
-        sys.exit(1)
-
-
-@app.command()
-def inspect(
-    server_spec: str = typer.Argument(
-        ...,
-        help="Python file to inspect, optionally with :object suffix",
-    ),
+@app.command
+async def inspect(
+    server_spec: str,
+    *,
     output: Annotated[
         Path,
-        typer.Option(
-            "--output",
-            "-o",
+        cyclopts.Parameter(
+            name=["--output", "-o"],
             help="Output file path for the JSON report (default: server-info.json)",
         ),
     ] = Path("server-info.json"),
 ) -> None:
-    """Inspect a FastMCP server and generate a JSON report.
+    """Inspect an MCP server and generate a JSON report.
 
-    This command analyzes a FastMCP server (v1.x or v2.x) and generates
-    a comprehensive JSON report containing information about the server's
-    name, instructions, version, tools, prompts, resources, templates,
-    and capabilities.
+    This command analyzes an MCP server and generates a comprehensive JSON report
+    containing information about the server's name, instructions, version, tools,
+    prompts, resources, templates, and capabilities.
 
     Examples:
         fastmcp inspect server.py
         fastmcp inspect server.py -o report.json
         fastmcp inspect server.py:mcp -o analysis.json
         fastmcp inspect path/to/server.py:app -o /tmp/server-info.json
-    """
 
+    Args:
+        server_spec: Python file to inspect, optionally with :object suffix
+    """
     # Parse the server specification
     file, server_object = run_module.parse_file_path(server_spec)
 
@@ -500,22 +383,8 @@ def inspect(
         # Import the server
         server = run_module.import_server(file, server_object)
 
-        # Get server information
-        async def get_info():
-            return await inspect_fastmcp(server)
-
-        try:
-            # Try to use existing event loop if available
-            asyncio.get_running_loop()
-            # If there's already a loop running, we need to run in a thread
-            import concurrent.futures
-
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(asyncio.run, get_info())
-                info = future.result()
-        except RuntimeError:
-            # No running loop, safe to use asyncio.run
-            info = asyncio.run(get_info())
+        # Get server information - using native async support
+        info = await inspect_fastmcp(server)
 
         info_json = TypeAdapter(FastMCPInfo).dump_json(info, indent=2)
 
@@ -548,3 +417,11 @@ def inspect(
         )
         console.print(f"[bold red]✗[/bold red] Failed to inspect server: {e}")
         sys.exit(1)
+
+
+# Add install subcommands using proper Cyclopts pattern
+app.command(install_app)
+
+
+if __name__ == "__main__":
+    app()

fastmcp/cli/install/__init__.py

@@ -0,0 +1,20 @@
+"""Install subcommands for FastMCP CLI using Cyclopts."""
+
+import cyclopts
+
+from .claude_code import claude_code_command
+from .claude_desktop import claude_desktop_command
+from .cursor import cursor_command
+from .mcp_config import mcp_config_command
+
+# Create a cyclopts app for install subcommands
+install_app = cyclopts.App(
+    name="install",
+    help="Install MCP servers in various clients and formats.",
+)
+
+# Register each command from its respective module
+install_app.command(claude_code_command, name="claude-code")
+install_app.command(claude_desktop_command, name="claude-desktop")
+install_app.command(cursor_command, name="cursor")
+install_app.command(mcp_config_command, name="mcp-json")

fastmcp/cli/install/claude_code.py

@@ -0,0 +1,186 @@
+"""Claude Code integration for FastMCP install using Cyclopts."""
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import cyclopts
+from rich import print
+
+from fastmcp.utilities.logging import get_logger
+
+from .shared import process_common_args
+
+logger = get_logger(__name__)
+
+
+def find_claude_command() -> str | None:
+    """Find the Claude Code CLI command."""
+    # Check the default installation location
+    default_path = Path.home() / ".claude" / "local" / "claude"
+    if default_path.exists():
+        try:
+            result = subprocess.run(
+                [str(default_path), "--version"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            if "Claude Code" in result.stdout:
+                return str(default_path)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            pass
+
+    return None
+
+
+def check_claude_code_available() -> bool:
+    """Check if Claude Code CLI is available."""
+    return find_claude_command() is not None
+
+
+def install_claude_code(
+    file: Path,
+    server_object: str | None,
+    name: str,
+    *,
+    with_editable: Path | None = None,
+    with_packages: list[str] | None = None,
+    env_vars: dict[str, str] | None = None,
+) -> bool:
+    """Install FastMCP server in Claude Code.
+
+    Args:
+        file: Path to the server file
+        server_object: Optional server object name (for :object suffix)
+        name: Name for the server in Claude Code
+        with_editable: Optional directory to install in editable mode
+        with_packages: Optional list of additional packages to install
+        env_vars: Optional dictionary of environment variables
+
+    Returns:
+        True if installation was successful, False otherwise
+    """
+    # Check if Claude Code CLI is available
+    claude_cmd = find_claude_command()
+    if not claude_cmd:
+        print(
+            "[red]Claude Code CLI not found.[/red]\n"
+            "[blue]Please ensure Claude Code is installed. Try running 'claude --version' to verify.[/blue]"
+        )
+        return False
+
+    # Build uv run command
+    args = ["run"]
+
+    # Collect all packages in a set to deduplicate
+    packages = {"fastmcp"}
+    if with_packages:
+        packages.update(pkg for pkg in with_packages if pkg)
+
+    # Add all packages with --with
+    for pkg in sorted(packages):
+        args.extend(["--with", pkg])
+
+    if with_editable:
+        args.extend(["--with-editable", str(with_editable)])
+
+    # Build server spec from parsed components
+    if server_object:
+        server_spec = f"{file.resolve()}:{server_object}"
+    else:
+        server_spec = str(file.resolve())
+
+    # Add fastmcp run command
+    args.extend(["fastmcp", "run", server_spec])
+
+    # Build claude mcp add command
+    cmd_parts = [claude_cmd, "mcp", "add"]
+
+    # Add environment variables if specified (before the name and command)
+    if env_vars:
+        for key, value in env_vars.items():
+            cmd_parts.extend(["-e", f"{key}={value}"])
+
+    # Add server name and command
+    cmd_parts.extend([name, "--"])
+    cmd_parts.extend(["uv"] + args)
+
+    try:
+        # Run the claude mcp add command
+        subprocess.run(cmd_parts, check=True, capture_output=True, text=True)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(
+            f"[red]Failed to install '[bold]{name}[/bold]' in Claude Code: {e.stderr.strip() if e.stderr else str(e)}[/red]"
+        )
+        return False
+    except Exception as e:
+        print(f"[red]Failed to install '[bold]{name}[/bold]' in Claude Code: {e}[/red]")
+        return False
+
+
+def claude_code_command(
+    server_spec: str,
+    *,
+    server_name: Annotated[
+        str | None,
+        cyclopts.Parameter(
+            name=["--server-name", "-n"],
+            help="Custom name for the server in Claude Code",
+        ),
+    ] = None,
+    with_editable: Annotated[
+        Path | None,
+        cyclopts.Parameter(
+            name=["--with-editable", "-e"],
+            help="Directory with pyproject.toml to install in editable mode",
+        ),
+    ] = None,
+    with_packages: Annotated[
+        list[str],
+        cyclopts.Parameter(
+            "--with",
+            help="Additional packages to install",
+            negative=False,
+        ),
+    ] = [],
+    env_vars: Annotated[
+        list[str],
+        cyclopts.Parameter(
+            "--env",
+            help="Environment variables in KEY=VALUE format",
+            negative=False,
+        ),
+    ] = [],
+    env_file: Annotated[
+        Path | None,
+        cyclopts.Parameter(
+            "--env-file",
+            help="Load environment variables from .env file",
+        ),
+    ] = None,
+) -> None:
+    """Install an MCP server in Claude Code.
+
+    Args:
+        server_spec: Python file to install, optionally with :object suffix
+    """
+    file, server_object, name, packages, env_dict = process_common_args(
+        server_spec, server_name, with_packages, env_vars, env_file
+    )
+
+    success = install_claude_code(
+        file=file,
+        server_object=server_object,
+        name=name,
+        with_editable=with_editable,
+        with_packages=packages,
+        env_vars=env_dict,
+    )
+
+    if success:
+        print(f"[green]Successfully installed '{name}' in Claude Code[/green]")
+    else:
+        sys.exit(1)