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

fastmcp/cli/install/mcp_config.py

@@ -0,0 +1,165 @@
+"""MCP configuration JSON generation for FastMCP install using Cyclopts."""
+
+import json
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import cyclopts
+import pyperclip
+from rich import print
+
+from fastmcp.utilities.logging import get_logger
+
+from .shared import process_common_args
+
+logger = get_logger(__name__)
+
+
+def install_mcp_config(
+    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,
+    copy: bool = False,
+) -> bool:
+    """Generate MCP configuration JSON for manual installation.
+
+    Args:
+        file: Path to the server file
+        server_object: Optional server object name (for :object suffix)
+        name: Name for the server in MCP config
+        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
+        copy: If True, copy to clipboard instead of printing to stdout
+
+    Returns:
+        True if generation was successful, False otherwise
+    """
+    try:
+        # 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 MCP server configuration (just the server object, not the wrapper)
+        config = {
+            "command": "uv",
+            "args": args,
+        }
+
+        # Add environment variables if provided
+        if env_vars:
+            config["env"] = env_vars
+
+        # Convert to JSON
+        json_output = json.dumps(config, indent=2)
+
+        # Handle output
+        if copy:
+            pyperclip.copy(json_output)
+            print(f"[green]MCP configuration for '{name}' copied to clipboard[/green]")
+        else:
+            # Print to stdout (for piping)
+            print(json_output)
+
+        return True
+
+    except Exception as e:
+        print(f"[red]Failed to generate MCP configuration: {e}[/red]")
+        return False
+
+
+def mcp_config_command(
+    server_spec: str,
+    *,
+    server_name: Annotated[
+        str | None,
+        cyclopts.Parameter(
+            name=["--server-name", "-n"],
+            help="Custom name for the server in MCP config",
+        ),
+    ] = 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,
+    copy: Annotated[
+        bool,
+        cyclopts.Parameter(
+            "--copy",
+            help="Copy configuration to clipboard instead of printing to stdout",
+            negative=False,
+        ),
+    ] = False,
+) -> None:
+    """Generate MCP configuration JSON for manual installation.
+
+    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_mcp_config(
+        file=file,
+        server_object=server_object,
+        name=name,
+        with_editable=with_editable,
+        with_packages=packages,
+        env_vars=env_dict,
+        copy=copy,
+    )
+
+    if not success:
+        sys.exit(1)

fastmcp/cli/install/shared.py

@@ -0,0 +1,85 @@
+"""Shared utilities for install commands."""
+
+import sys
+from pathlib import Path
+
+from dotenv import dotenv_values
+from rich import print
+
+from fastmcp.cli.run import import_server, parse_file_path
+from fastmcp.utilities.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def parse_env_var(env_var: str) -> tuple[str, str]:
+    """Parse environment variable string in format KEY=VALUE."""
+    if "=" not in env_var:
+        print(
+            f"[red]Invalid environment variable format: '[bold]{env_var}[/bold]'. Must be KEY=VALUE[/red]"
+        )
+        sys.exit(1)
+    key, value = env_var.split("=", 1)
+    return key.strip(), value.strip()
+
+
+def process_common_args(
+    server_spec: str,
+    server_name: str | None,
+    with_packages: list[str],
+    env_vars: list[str],
+    env_file: Path | None,
+) -> tuple[Path, str | None, str, list[str], dict[str, str] | None]:
+    """Process common arguments shared by all install commands."""
+    # Parse server spec
+    file, server_object = parse_file_path(server_spec)
+
+    logger.debug(
+        "Installing server",
+        extra={
+            "file": str(file),
+            "server_name": server_name,
+            "server_object": server_object,
+            "with_packages": with_packages,
+        },
+    )
+
+    # Try to import server to get its name and dependencies
+    name = server_name
+    server = None
+    if not name:
+        try:
+            server = 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_values(env_file).items() if v is not None
+                }
+            except Exception as e:
+                print(f"[red]Failed to load .env file: {e}[/red]")
+                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
+
+    return file, server_object, name, with_packages, env_dict

fastmcp/cli/run.py

@@ -1,15 +1,19 @@
-"""FastMCP run command implementation."""
+"""FastMCP run command implementation with enhanced type hints."""
 
 import importlib.util
 import re
 import sys
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 from fastmcp.utilities.logging import get_logger
 
 logger = get_logger("cli.run")
 
+# Type aliases for better type safety
+TransportType = Literal["stdio", "http", "sse"]
+LogLevelType = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
 
 def is_url(path: str) -> bool:
     """Check if a string is a URL."""
@@ -164,11 +168,13 @@ def import_server_with_args(
 
 def run_command(
     server_spec: str,
-    transport: str | None = None,
+    transport: TransportType | None = None,
     host: str | None = None,
     port: int | None = None,
-    log_level: str | None = None,
+    path: str | None = None,
+    log_level: LogLevelType | None = None,
     server_args: list[str] | None = None,
+    show_banner: bool = True,
 ) -> None:
     """Run a MCP server or connect to a remote one.
 
@@ -177,8 +183,10 @@ def run_command(
         transport: Transport protocol to use
         host: Host to bind to when using http transport
         port: Port to bind to when using http transport
+        path: Path to bind to when using http transport
         log_level: Log level
         server_args: Additional arguments to pass to the server
+        show_banner: Whether to show the server banner
     """
     if is_url(server_spec):
         # Handle URL case
@@ -198,9 +206,14 @@ def run_command(
         kwargs["host"] = host
     if port:
         kwargs["port"] = port
+    if path:
+        kwargs["path"] = path
     if log_level:
         kwargs["log_level"] = log_level
 
+    if not show_banner:
+        kwargs["show_banner"] = False
+
     try:
         server.run(**kwargs)
     except Exception as e: