fastmcp 2.12.1__py3-none-any.whl → 2.13.2__py3-none-any.whl

fastmcp/__init__.py

@@ -48,9 +48,9 @@ def __getattr__(name: str):
 
 
 __all__ = [
-    "FastMCP",
+    "Client",
     "Context",
+    "FastMCP",
     "client",
-    "Client",
     "settings",
 ]

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,
@@ -45,9 +46,7 @@ def _get_npx_command():
         # Try both npx.cmd and npx.exe on Windows
         for cmd in ["npx.cmd", "npx.exe", "npx"]:
             try:
-                subprocess.run(
-                    [cmd, "--version"], check=True, capture_output=True, shell=True
-                )
+                subprocess.run([cmd, "--version"], check=True, capture_output=True)
                 return cmd
             except subprocess.CalledProcessError:
                 continue
@@ -79,7 +78,7 @@ def with_argv(args: list[str] | None):
         original = sys.argv[:]
         try:
             # Preserve the script name (sys.argv[0]) and replace the rest
-            sys.argv = [sys.argv[0]] + args
+            sys.argv = [sys.argv[0], *args]
             yield
         finally:
             sys.argv = original
@@ -193,7 +192,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
@@ -277,12 +275,10 @@ async def dev(
         # Set marker to prevent infinite loops when subprocess calls FastMCP
         env = dict(os.environ.items()) | env_vars | {"FASTMCP_UV_SPAWNED": "1"}
 
-        # Run the MCP Inspector command with shell=True on Windows
-        shell = sys.platform == "win32"
+        # Run the MCP Inspector command
         process = subprocess.run(
-            [npx_cmd, inspector_cmd] + uv_cmd,
+            [npx_cmd, inspector_cmd, *uv_cmd],
             check=True,
-            shell=shell,
             env=env,
         )
         sys.exit(process.returncode)
@@ -415,7 +411,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 +441,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 +464,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:
-            logger.error(
+            process = subprocess.run(cmd, check=True, env=env)
+            sys.exit(process.returncode)
+        except subprocess.CalledProcessError as e:
+            logger.exception(
                 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,11 +522,11 @@ 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:
-            logger.error(
+            logger.exception(
                 f"Failed to run: {e}",
                 extra={
                     "server_spec": server_spec,
@@ -598,7 +614,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 +656,7 @@ async def inspect(
             "fastmcp",
             "inspect",
             server_spec,
+            "--skip-env",  # Prevent infinite recursion
         ]
 
         # Add format and output flags if specified
@@ -697,6 +713,10 @@ async def inspect(
             console.print(f"  Name:         {info.name}")
             if info.version:
                 console.print(f"  Version:      {info.version}")
+            if info.website_url:
+                console.print(f"  Website:      {info.website_url}")
+            if info.icons:
+                console.print(f"  Icons:        {len(info.icons)}")
             console.print(f"  Generation:   {info.server_generation}")
             if info.instructions:
                 console.print(f"  Instructions: {info.instructions}")
@@ -746,7 +766,7 @@ async def inspect(
             console.print(formatted_json.decode("utf-8"))
 
     except Exception as e:
-        logger.error(
+        logger.exception(
             f"Failed to inspect server: {e}",
             extra={
                 "server_spec": server_spec,

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,21 +107,12 @@ 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,
-        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,
+        dependencies=(with_packages or []) + ["fastmcp"],
+        requirements=with_requirements,
+        project=project,
+        editable=with_editable,
     )
 
     # Build server spec from parsed components
@@ -134,15 +125,15 @@ def install_claude_code(
     full_command = env_config.build_command(["fastmcp", "run", server_spec])
 
     # Build claude mcp add command
-    cmd_parts = [claude_cmd, "mcp", "add"]
+    cmd_parts = [claude_cmd, "mcp", "add", name]
 
-    # Add environment variables if specified (before the name and command)
+    # Add environment variables if specified
     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.append("--")
     cmd_parts.extend(full_command)
 
     try:

fastmcp/cli/install/claude_desktop.py

@@ -73,20 +73,12 @@ 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,
-        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,
+        dependencies=(with_packages or []) + ["fastmcp"],
+        requirements=with_requirements,
+        project=project,
+        editable=with_editable,
     )
     # Build server spec from parsed components
     if server_object:

fastmcp/cli/install/cursor.py

@@ -1,10 +1,12 @@
 """Cursor integration for FastMCP install using Cyclopts."""
 
 import base64
+import os
 import subprocess
 import sys
 from pathlib import Path
 from typing import Annotated
+from urllib.parse import quote, urlparse
 
 import cyclopts
 from rich import print
@@ -36,8 +38,9 @@ def generate_cursor_deeplink(
     config_json = server_config.model_dump_json(exclude_none=True)
     config_b64 = base64.urlsafe_b64encode(config_json.encode()).decode()
 
-    # Generate the deeplink URL
-    deeplink = f"cursor://anysphere.cursor-deeplink/mcp/install?name={server_name}&config={config_b64}"
+    # Generate the deeplink URL with properly encoded server name
+    encoded_name = quote(server_name, safe="")
+    deeplink = f"cursor://anysphere.cursor-deeplink/mcp/install?name={encoded_name}&config={config_b64}"
 
     return deeplink
 
@@ -51,17 +54,20 @@ def open_deeplink(deeplink: str) -> bool:
     Returns:
         True if the command succeeded, False otherwise
     """
+    parsed = urlparse(deeplink)
+    if parsed.scheme != "cursor":
+        logger.warning(f"Invalid deeplink scheme: {parsed.scheme}")
+        return False
+
     try:
         if sys.platform == "darwin":  # macOS
             subprocess.run(["open", deeplink], check=True, capture_output=True)
         elif sys.platform == "win32":  # Windows
-            subprocess.run(
-                ["start", deeplink], shell=True, check=True, capture_output=True
-            )
+            os.startfile(deeplink)
         else:  # Linux and others
             subprocess.run(["xdg-open", deeplink], check=True, capture_output=True)
         return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
+    except (subprocess.CalledProcessError, FileNotFoundError, OSError):
         return False
 
 
@@ -107,20 +113,12 @@ 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,
-        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,
+        dependencies=(with_packages or []) + ["fastmcp"],
+        requirements=with_requirements,
+        project=project,
+        editable=with_editable,
     )
     # Build server spec from parsed components
     if server_object:
@@ -185,20 +183,12 @@ 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,
-        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,
+        dependencies=(with_packages or []) + ["fastmcp"],
+        requirements=with_requirements,
+        project=project,
+        editable=with_editable,
     )
     # Build server spec from parsed components
     if server_object:

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=with_requirements,
+        project=project,
+        editable=with_editable,
+    )
+
+    # 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,20 +48,12 @@ 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,
-            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,
+            dependencies=(with_packages or []) + ["fastmcp"],
+            requirements=with_requirements,
+            project=project,
+            editable=with_editable,
         )
         # Build server spec from parsed components
         if server_object: