fastmcp 2.12.2__py3-none-any.whl → 2.12.4__py3-none-any.whl

fastmcp/cli/claude.py

@@ -90,17 +90,8 @@ def update_claude_config(
             else:
                 env_vars = existing_env
 
-        # Deduplicate packages and exclude 'fastmcp' since Environment adds it automatically
-        deduplicated_packages = None
-        if with_packages:
-            deduplicated = list(dict.fromkeys(with_packages))
-            deduplicated_packages = [pkg for pkg in deduplicated if pkg != "fastmcp"]
-            if not deduplicated_packages:
-                deduplicated_packages = None
-
-        # Build uv run command using Environment.build_uv_run_command()
         env_config = UVEnvironment(
-            dependencies=deduplicated_packages,
+            dependencies=(with_packages or []) + ["fastmcp"],
             editable=[str(p) for p in with_editable] if with_editable else None,
         )
 

fastmcp/cli/cli.py

@@ -20,6 +20,7 @@ import fastmcp
 from fastmcp.cli import run as run_module
 from fastmcp.cli.install import install_app
 from fastmcp.server.server import FastMCP
+from fastmcp.utilities.cli import is_already_in_uv_subprocess, load_and_merge_config
 from fastmcp.utilities.inspect import (
     InspectFormat,
     format_info,
@@ -193,7 +194,6 @@ async def dev(
     Args:
         server_spec: Python file to run, optionally with :object suffix, or None to auto-detect fastmcp.json
     """
-    from fastmcp.utilities.cli import load_and_merge_config
 
     try:
         # Load config and apply CLI overrides
@@ -415,7 +415,6 @@ async def run(
     Args:
         server_spec: Python file, object specification (file:obj), config file, URL, or None to auto-detect
     """
-    from fastmcp.utilities.cli import is_already_in_uv_subprocess, load_and_merge_config
 
     # Check if we were spawned by uv (or user explicitly set --skip-env)
     if skip_env or is_already_in_uv_subprocess():
@@ -446,6 +445,9 @@ async def run(
     final_path = path or config.deployment.path
     final_log_level = log_level or config.deployment.log_level
     final_server_args = server_args or config.deployment.args
+    # Use CLI override if provided, otherwise use settings
+    # no_banner CLI flag overrides the show_cli_banner setting
+    final_no_banner = no_banner if no_banner else not fastmcp.settings.show_cli_banner
 
     logger.debug(
         "Running server or client",
@@ -466,35 +468,53 @@ async def run(
     needs_uv = config.environment.build_command(test_cmd) != test_cmd and not skip_env
 
     if needs_uv:
-        # Use uv run subprocess - always use run_with_uv which handles output correctly
+        # Build the inner fastmcp command
+        inner_cmd = ["fastmcp", "run", server_spec]
+
+        # Add transport options to the inner command
+        if final_transport:
+            inner_cmd.extend(["--transport", final_transport])
+        # Only add HTTP-specific options for non-stdio transports
+        if final_transport != "stdio":
+            if final_host:
+                inner_cmd.extend(["--host", final_host])
+            if final_port:
+                inner_cmd.extend(["--port", str(final_port)])
+            if final_path:
+                inner_cmd.extend(["--path", final_path])
+        if final_log_level:
+            inner_cmd.extend(["--log-level", final_log_level])
+        if final_no_banner:
+            inner_cmd.append("--no-banner")
+        # Add skip-env flag to prevent infinite recursion
+        inner_cmd.append("--skip-env")
+
+        # Add server args if any
+        if final_server_args:
+            inner_cmd.append("--")
+            inner_cmd.extend(final_server_args)
+
+        # Build the full uv command using the config's environment
+        cmd = config.environment.build_command(inner_cmd)
+
+        # Set marker to prevent infinite loops when subprocess calls FastMCP again
+        env = os.environ | {"FASTMCP_UV_SPAWNED": "1"}
+
+        # Run the command
+        logger.debug(f"Running command: {' '.join(cmd)}")
         try:
-            run_module.run_with_uv(
-                server_spec=server_spec,
-                python_version=config.environment.python,
-                with_packages=config.environment.dependencies,
-                with_requirements=Path(config.environment.requirements)
-                if config.environment.requirements
-                else None,
-                project=Path(config.environment.project)
-                if config.environment.project
-                else None,
-                transport=final_transport,
-                host=final_host,
-                port=final_port,
-                path=final_path,
-                log_level=final_log_level,
-                show_banner=not no_banner,
-                editable=config.environment.editable,
-            )
-        except Exception as e:
+            process = subprocess.run(cmd, check=True, env=env)
+            sys.exit(process.returncode)
+        except subprocess.CalledProcessError as e:
             logger.error(
                 f"Failed to run: {e}",
                 extra={
                     "server_spec": server_spec,
                     "error": str(e),
+                    "returncode": e.returncode,
                 },
             )
-            sys.exit(1)
+            sys.exit(e.returncode)
     else:
         # Use direct import for backwards compatibility
         try:
@@ -506,7 +526,7 @@ async def run(
                 path=final_path,
                 log_level=final_log_level,
                 server_args=list(final_server_args) if final_server_args else [],
-                show_banner=not no_banner,
+                show_banner=not final_no_banner,
                 skip_source=skip_source,
             )
         except Exception as e:
@@ -598,7 +618,6 @@ async def inspect(
     Args:
         server_spec: Python file to inspect, optionally with :object suffix, or fastmcp.json
     """
-    from fastmcp.utilities.cli import is_already_in_uv_subprocess, load_and_merge_config
 
     # Check if we were spawned by uv (or user explicitly set --skip-env)
     if skip_env or is_already_in_uv_subprocess():
@@ -641,6 +660,7 @@ async def inspect(
             "fastmcp",
             "inspect",
             server_spec,
+            "--skip-env",  # Prevent infinite recursion
         ]
 
         # Add format and output flags if specified

fastmcp/cli/install/__init__.py

@@ -5,6 +5,7 @@ import cyclopts
 from .claude_code import claude_code_command
 from .claude_desktop import claude_desktop_command
 from .cursor import cursor_command
+from .gemini_cli import gemini_cli_command
 from .mcp_json import mcp_json_command
 
 # Create a cyclopts app for install subcommands
@@ -17,4 +18,5 @@ install_app = cyclopts.App(
 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(gemini_cli_command, name="gemini-cli")
 install_app.command(mcp_json_command, name="mcp-json")

fastmcp/cli/install/claude_code.py

@@ -107,18 +107,9 @@ def install_claude_code(
         )
         return False
 
-    # Deduplicate packages and exclude 'fastmcp' since Environment adds it automatically
-    deduplicated_packages = None
-    if with_packages:
-        deduplicated = list(dict.fromkeys(with_packages))
-        deduplicated_packages = [pkg for pkg in deduplicated if pkg != "fastmcp"]
-        if not deduplicated_packages:
-            deduplicated_packages = None
-
-    # Build uv run command using Environment.build_uv_run_command()
     env_config = UVEnvironment(
         python=python_version,
-        dependencies=deduplicated_packages,
+        dependencies=(with_packages or []) + ["fastmcp"],
         requirements=str(with_requirements) if with_requirements else None,
         project=str(project) if project else None,
         editable=[str(p) for p in with_editable] if with_editable else None,

fastmcp/cli/install/claude_desktop.py

@@ -73,17 +73,9 @@ def install_claude_desktop(
 
     config_file = config_dir / "claude_desktop_config.json"
 
-    # Deduplicate packages and exclude 'fastmcp' since Environment adds it automatically
-    deduplicated_packages = None
-    if with_packages:
-        deduplicated = list(dict.fromkeys(with_packages))
-        deduplicated_packages = [pkg for pkg in deduplicated if pkg != "fastmcp"]
-        if not deduplicated_packages:
-            deduplicated_packages = None
-
     env_config = UVEnvironment(
         python=python_version,
-        dependencies=deduplicated_packages,
+        dependencies=(with_packages or []) + ["fastmcp"],
         requirements=str(with_requirements) if with_requirements else None,
         project=str(project) if project else None,
         editable=[str(p) for p in with_editable] if with_editable else None,

fastmcp/cli/install/cursor.py

@@ -107,17 +107,9 @@ def install_cursor_workspace(
 
     config_file = cursor_dir / "mcp.json"
 
-    # Deduplicate packages and exclude 'fastmcp' since Environment adds it automatically
-    deduplicated_packages = None
-    if with_packages:
-        deduplicated = list(dict.fromkeys(with_packages))
-        deduplicated_packages = [pkg for pkg in deduplicated if pkg != "fastmcp"]
-        if not deduplicated_packages:
-            deduplicated_packages = None
-
     env_config = UVEnvironment(
         python=python_version,
-        dependencies=deduplicated_packages,
+        dependencies=(with_packages or []) + ["fastmcp"],
         requirements=str(with_requirements.resolve()) if with_requirements else None,
         project=str(project.resolve()) if project else None,
         editable=[str(p.resolve()) for p in with_editable] if with_editable else None,
@@ -185,17 +177,9 @@ def install_cursor(
         True if installation was successful, False otherwise
     """
 
-    # Deduplicate packages and exclude 'fastmcp' since Environment adds it automatically
-    deduplicated_packages = None
-    if with_packages:
-        deduplicated = list(dict.fromkeys(with_packages))
-        deduplicated_packages = [pkg for pkg in deduplicated if pkg != "fastmcp"]
-        if not deduplicated_packages:
-            deduplicated_packages = None
-
     env_config = UVEnvironment(
         python=python_version,
-        dependencies=deduplicated_packages,
+        dependencies=(with_packages or []) + ["fastmcp"],
         requirements=str(with_requirements.resolve()) if with_requirements else None,
         project=str(project.resolve()) if project else None,
         editable=[str(p.resolve()) for p in with_editable] if with_editable else None,

fastmcp/cli/install/gemini_cli.py

@@ -0,0 +1,241 @@
+"""Gemini CLI integration for FastMCP install using Cyclopts."""
+
+import shutil
+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 fastmcp.utilities.mcp_server_config.v1.environments.uv import UVEnvironment
+
+from .shared import process_common_args
+
+logger = get_logger(__name__)
+
+
+def find_gemini_command() -> str | None:
+    """Find the Gemini CLI command."""
+    # First try shutil.which() in case it's a real executable in PATH
+    gemini_in_path = shutil.which("gemini")
+    if gemini_in_path:
+        try:
+            # If 'gemini --version' fails, it's not the correct path
+            subprocess.run(
+                [gemini_in_path, "--version"],
+                check=True,
+                capture_output=True,
+            )
+            return gemini_in_path
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            pass
+
+    # Check common installation locations (aliases don't work with subprocess)
+    potential_paths = [
+        # Default Gemini CLI installation location (after migration)
+        Path.home() / ".gemini" / "local" / "gemini",
+        # npm global installation on macOS/Linux (default)
+        Path("/usr/local/bin/gemini"),
+        # npm global installation with custom prefix
+        Path.home() / ".npm-global" / "bin" / "gemini",
+        # Homebrew installation on macOS
+        Path("/opt/homebrew/bin/gemini"),
+    ]
+
+    for path in potential_paths:
+        if path.exists():
+            # If 'gemini --version' fails, it's not the correct path
+            try:
+                subprocess.run(
+                    [str(path), "--version"],
+                    check=True,
+                    capture_output=True,
+                )
+                return str(path)
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                continue
+
+    return None
+
+
+def check_gemini_cli_available() -> bool:
+    """Check if Gemini CLI is available."""
+    return find_gemini_command() is not None
+
+
+def install_gemini_cli(
+    file: Path,
+    server_object: str | None,
+    name: str,
+    *,
+    with_editable: list[Path] | None = None,
+    with_packages: list[str] | None = None,
+    env_vars: dict[str, str] | None = None,
+    python_version: str | None = None,
+    with_requirements: Path | None = None,
+    project: Path | None = None,
+) -> bool:
+    """Install FastMCP server in Gemini CLI.
+
+    Args:
+        file: Path to the server file
+        server_object: Optional server object name (for :object suffix)
+        name: Name for the server in Gemini CLI
+        with_editable: Optional list of directories to install in editable mode
+        with_packages: Optional list of additional packages to install
+        env_vars: Optional dictionary of environment variables
+        python_version: Optional Python version to use
+        with_requirements: Optional requirements file to install from
+        project: Optional project directory to run within
+
+    Returns:
+        True if installation was successful, False otherwise
+    """
+    # Check if Gemini CLI is available
+    gemini_cmd = find_gemini_command()
+    if not gemini_cmd:
+        print(
+            "[red]Gemini CLI not found.[/red]\n"
+            "[blue]Please ensure Gemini CLI is installed. Try running 'gemini --version' to verify.[/blue]\n"
+            "[blue]You can install it using 'npm install -g @google/gemini-cli'.[/blue]\n"
+        )
+        return False
+
+    env_config = UVEnvironment(
+        python=python_version,
+        dependencies=(with_packages or []) + ["fastmcp"],
+        requirements=str(with_requirements) if with_requirements else None,
+        project=str(project) if project else None,
+        editable=[str(p) for p in with_editable] if with_editable else None,
+    )
+
+    # Build server spec from parsed components
+    if server_object:
+        server_spec = f"{file.resolve()}:{server_object}"
+    else:
+        server_spec = str(file.resolve())
+
+    # Build the full command
+    full_command = env_config.build_command(["fastmcp", "run", server_spec])
+
+    # Build gemini mcp add command
+    cmd_parts = [gemini_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, full_command[0], "--"])
+    cmd_parts.extend(full_command[1:])
+
+    try:
+        # Run the gemini 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 Gemini CLI: {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 Gemini CLI: {e}[/red]")
+        return False
+
+
+async def gemini_cli_command(
+    server_spec: str,
+    *,
+    server_name: Annotated[
+        str | None,
+        cyclopts.Parameter(
+            name=["--name", "-n"],
+            help="Custom name for the server in Gemini CLI",
+        ),
+    ] = None,
+    with_editable: Annotated[
+        list[Path] | None,
+        cyclopts.Parameter(
+            "--with-editable",
+            help="Directory with pyproject.toml to install in editable mode (can be used multiple times)",
+            negative="",
+        ),
+    ] = None,
+    with_packages: Annotated[
+        list[str] | None,
+        cyclopts.Parameter(
+            "--with",
+            help="Additional packages to install (can be used multiple times)",
+            negative="",
+        ),
+    ] = None,
+    env_vars: Annotated[
+        list[str] | None,
+        cyclopts.Parameter(
+            "--env",
+            help="Environment variables in KEY=VALUE format (can be used multiple times)",
+            negative="",
+        ),
+    ] = None,
+    env_file: Annotated[
+        Path | None,
+        cyclopts.Parameter(
+            "--env-file",
+            help="Load environment variables from .env file",
+        ),
+    ] = None,
+    python: Annotated[
+        str | None,
+        cyclopts.Parameter(
+            "--python",
+            help="Python version to use (e.g., 3.10, 3.11)",
+        ),
+    ] = None,
+    with_requirements: Annotated[
+        Path | None,
+        cyclopts.Parameter(
+            "--with-requirements",
+            help="Requirements file to install dependencies from",
+        ),
+    ] = None,
+    project: Annotated[
+        Path | None,
+        cyclopts.Parameter(
+            "--project",
+            help="Run the command within the given project directory",
+        ),
+    ] = None,
+) -> None:
+    """Install an MCP server in Gemini CLI.
+
+    Args:
+        server_spec: Python file to install, optionally with :object suffix
+    """
+    # Convert None to empty lists for list parameters
+    with_editable = with_editable or []
+    with_packages = with_packages or []
+    env_vars = env_vars or []
+    file, server_object, name, packages, env_dict = await process_common_args(
+        server_spec, server_name, with_packages, env_vars, env_file
+    )
+
+    success = install_gemini_cli(
+        file=file,
+        server_object=server_object,
+        name=name,
+        with_editable=with_editable,
+        with_packages=packages,
+        env_vars=env_dict,
+        python_version=python,
+        with_requirements=with_requirements,
+        project=project,
+    )
+
+    if success:
+        print(f"[green]Successfully installed '{name}' in Gemini CLI")
+    else:
+        sys.exit(1)

fastmcp/cli/install/mcp_json.py

@@ -48,17 +48,9 @@ def install_mcp_json(
         True if generation was successful, False otherwise
     """
     try:
-        # Deduplicate packages and exclude 'fastmcp' since Environment adds it automatically
-        deduplicated_packages = None
-        if with_packages:
-            deduplicated = list(dict.fromkeys(with_packages))
-            deduplicated_packages = [pkg for pkg in deduplicated if pkg != "fastmcp"]
-            if not deduplicated_packages:
-                deduplicated_packages = None
-
         env_config = UVEnvironment(
             python=python_version,
-            dependencies=deduplicated_packages,
+            dependencies=(with_packages or []) + ["fastmcp"],
             requirements=str(with_requirements) if with_requirements else None,
             project=str(project) if project else None,
             editable=[str(p) for p in with_editable] if with_editable else None,

fastmcp/cli/run.py

@@ -1,9 +1,7 @@
 """FastMCP run command implementation with enhanced type hints."""
 
 import json
-import os
 import re
-import subprocess
 import sys
 from pathlib import Path
 from typing import Any, Literal
@@ -15,7 +13,6 @@ from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.mcp_server_config import (
     MCPServerConfig,
 )
-from fastmcp.utilities.mcp_server_config.v1.environments.uv import UVEnvironment
 from fastmcp.utilities.mcp_server_config.v1.sources.filesystem import FileSystemSource
 
 logger = get_logger("cli.run")
@@ -31,87 +28,6 @@ def is_url(path: str) -> bool:
     return bool(url_pattern.match(path))
 
 
-def run_with_uv(
-    server_spec: str,
-    python_version: str | None = None,
-    with_packages: list[str] | None = None,
-    with_requirements: Path | None = None,
-    project: Path | None = None,
-    transport: TransportType | None = None,
-    host: str | None = None,
-    port: int | None = None,
-    path: str | None = None,
-    log_level: LogLevelType | None = None,
-    show_banner: bool = True,
-    editable: str | list[str] | None = None,
-) -> None:
-    """Run a MCP server using uv run subprocess.
-
-    This function is called when we need to set up a Python environment with specific
-    dependencies before running the server. The config parsing and merging should already
-    be done by the caller.
-
-    Args:
-        server_spec: Python file, object specification (file:obj), config file, or URL
-        python_version: Python version to use (e.g. "3.10")
-        with_packages: Additional packages to install
-        with_requirements: Requirements file to use
-        project: Run the command within the given project directory
-        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
-        show_banner: Whether to show the server banner
-        editable: Editable package paths
-    """
-
-    # Build uv command using Environment.build_uv_run_command()
-    env_config = UVEnvironment(
-        python=python_version,
-        dependencies=with_packages if with_packages else None,
-        requirements=str(with_requirements.resolve()) if with_requirements else None,
-        project=str(project.resolve()) if project else None,
-        editable=editable
-        if isinstance(editable, list)
-        else ([editable] if editable else None),
-    )
-
-    # Build the inner fastmcp command (environment variable prevents infinite recursion)
-    inner_cmd = ["fastmcp", "run", server_spec]
-
-    # Add transport options to the inner command
-    if transport:
-        inner_cmd.extend(["--transport", transport])
-    # Only add HTTP-specific options for non-stdio transports
-    if transport != "stdio":
-        if host:
-            inner_cmd.extend(["--host", host])
-        if port:
-            inner_cmd.extend(["--port", str(port)])
-        if path:
-            inner_cmd.extend(["--path", path])
-    if log_level:
-        inner_cmd.extend(["--log-level", log_level])
-    if not show_banner:
-        inner_cmd.append("--no-banner")
-
-    # Build the full uv command
-    cmd = env_config.build_command(inner_cmd)
-
-    # Set marker to prevent infinite loops when subprocess calls FastMCP again
-    env = os.environ | {"FASTMCP_UV_SPAWNED": "1"}
-
-    # Run the command
-    logger.debug(f"Running command: {' '.join(cmd)}")
-    try:
-        process = subprocess.run(cmd, check=True, env=env)
-        sys.exit(process.returncode)
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Failed to run server: {e}")
-        sys.exit(e.returncode)
-
-
 def create_client_server(url: str) -> Any:
     """Create a FastMCP server from a client URL.
 
@@ -268,8 +184,8 @@ async def run_command(
         kwargs["port"] = port
     if path:
         kwargs["path"] = path
-    # Note: log_level is not currently supported by run_async
-    # TODO: Add log_level support to server.run_async
+    if log_level:
+        kwargs["log_level"] = log_level
 
     if not show_banner:
         kwargs["show_banner"] = False