Skip to content

πŸš€ The fast, Pythonic way to build MCP servers and clients.

Consolidate CLI config parsing and prevent infinite loops (#1660)

Jeremiah Lowin536ccde9e88c
diff --git a/src/fastmcp/cli/claude.py b/src/fastmcp/cli/claude.py
index 8873a3a7a..af42da058 100644
--- a/src/fastmcp/cli/claude.py
+++ b/src/fastmcp/cli/claude.py
@@ -98,12 +98,11 @@ def update_claude_config(
if not deduplicated_packages:
deduplicated_packages = None
- # Build uv run command using Environment.build_uv_args()
+ # Build uv run command using Environment.build_uv_run_command()
env_config = Environment(
dependencies=deduplicated_packages,
editable=[str(p) for p in with_editable] if with_editable else None,
)
- args = env_config.build_uv_args()
# Convert file path to absolute before adding to command
# Split off any :object suffix first
@@ -113,10 +112,14 @@ def update_claude_config(
else:
file_spec = str(Path(file_spec).resolve())
- # Add fastmcp run command
- args.extend(["fastmcp", "run", file_spec])
+ # Build the full command
+ full_command = env_config.build_uv_run_command(["fastmcp", "run", file_spec])
- server_config: dict[str, Any] = {"command": "uv", "args": args}
+ # Extract command and args for the config
+ server_config: dict[str, Any] = {
+ "command": full_command[0],
+ "args": full_command[1:],
+ }
# Add environment variables if specified
if env_vars:
diff --git a/src/fastmcp/cli/cli.py b/src/fastmcp/cli/cli.py
index 34e1a908c..09de389db 100644
--- a/src/fastmcp/cli/cli.py
+++ b/src/fastmcp/cli/cli.py
@@ -13,7 +13,6 @@ from typing import Annotated, Literal
import cyclopts
import pyperclip
-from pydantic import ValidationError
from rich.console import Console
from rich.table import Table
@@ -22,14 +21,12 @@ from fastmcp.cli import run as run_module
from fastmcp.cli.install import install_app
from fastmcp.server.server import FastMCP
from fastmcp.utilities.fastmcp_config import Environment, FastMCPConfig
-from fastmcp.utilities.fastmcp_config.v1.sources.filesystem import FileSystemSource
from fastmcp.utilities.inspect import (
InspectFormat,
format_info,
inspect_fastmcp,
)
from fastmcp.utilities.logging import get_logger
-from fastmcp.utilities.types import get_cached_typeadapter
logger = get_logger("cli")
console = Console()
@@ -195,75 +192,33 @@ async def dev(
Args:
server_spec: Python file to run, optionally with :object suffix, or None to auto-detect fastmcp.json
"""
- # Convert None to empty lists for list parameters
- with_editable = with_editable or []
- with_packages = with_packages or []
- from pathlib import Path
+ from fastmcp.utilities.cli import load_and_merge_config
- from fastmcp.utilities.fastmcp_config import FastMCPConfig
- from fastmcp.utilities.fastmcp_config.v1.sources.filesystem import FileSystemSource
+ try:
+ # Load config and apply CLI overrides
+ config, server_spec = load_and_merge_config(
+ server_spec,
+ python=python,
+ with_packages=with_packages or [],
+ with_requirements=with_requirements,
+ project=project,
+ editable=[str(p) for p in with_editable] if with_editable else None,
+ port=server_port, # Use deployment config for server port
+ )
- config = None
- config_path = None
+ # Get server port from config if not specified via CLI
+ if not server_port:
+ server_port = config.deployment.port
- # Auto-detect fastmcp.json if no server_spec provided
- if server_spec is None:
- config_path = Path("fastmcp.json")
- if not config_path.exists():
- # Check if fastmcp.json exists in current directory
- found_config = FastMCPConfig.find_config()
- if found_config:
- config_path = found_config
- else:
- logger.error(
- "No server specification provided and no fastmcp.json found in current directory.\n"
- "Please specify a server file or create a fastmcp.json configuration."
- )
- sys.exit(1)
- server_spec = str(config_path)
- logger.info(f"Using configuration from {config_path}")
-
- # Create FastMCPConfig from server_spec
- if server_spec.endswith(".json"):
- # Load existing config
- config = FastMCPConfig.from_file(Path(server_spec))
-
- # Merge environment settings with CLI args (CLI takes precedence)
- if config.environment:
- python = python or config.environment.python
- project = project or (
- Path(config.environment.project) if config.environment.project else None
- )
- with_requirements = with_requirements or (
- Path(config.environment.requirements)
- if config.environment.requirements
- else None
- )
- # Merge editable paths from config with CLI args
- if config.environment.editable and not with_editable:
- with_editable = [Path(p) for p in config.environment.editable]
-
- # Merge packages from both sources
- if config.environment.dependencies:
- packages = list(config.environment.dependencies)
- if with_packages:
- packages.extend(with_packages)
- with_packages = packages
-
- # Get server port from deployment config if not specified
- if config.deployment and config.deployment.port:
- server_port = server_port or config.deployment.port
- else:
- # Create config from file path
- source = FileSystemSource(path=server_spec)
- config = FastMCPConfig(source=source)
+ except FileNotFoundError:
+ sys.exit(1)
logger.debug(
"Starting dev server",
extra={
"server_spec": server_spec,
- "with_editable": [str(p) for p in with_editable] if with_editable else None,
- "with_packages": with_packages,
+ "with_editable": config.environment.editable,
+ "with_packages": config.environment.dependencies,
"ui_port": ui_port,
"server_port": server_port,
},
@@ -271,6 +226,10 @@ async def dev(
try:
# Load server to check for deprecated dependencies
+ if not config:
+ logger.error("No configuration available")
+ sys.exit(1)
+ assert config is not None # For type checker
server: FastMCP = await config.source.load_server()
if server.dependencies:
import warnings
@@ -282,7 +241,13 @@ async def dev(
DeprecationWarning,
stacklevel=2,
)
- with_packages = list(set(with_packages + server.dependencies))
+ # Merge server dependencies with environment dependencies
+ env_deps = config.environment.dependencies or []
+ all_deps = list(set(env_deps + server.dependencies))
+ if not config.environment:
+ config.environment = Environment(dependencies=all_deps)
+ else:
+ config.environment.dependencies = all_deps
env_vars = {}
if ui_port:
@@ -303,18 +268,13 @@ async def dev(
if inspector_version:
inspector_cmd += f"@{inspector_version}"
- # Create Environment object from CLI args
- env_config = Environment(
- python=python,
- dependencies=with_packages if with_packages else None,
- 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,
+ # Use the environment from config (already has CLI overrides applied)
+ uv_cmd = config.environment.build_uv_run_command(
+ ["fastmcp", "run", server_spec, "--no-banner"]
)
- uv_cmd = ["uv"] + env_config.build_uv_args(["fastmcp", "run", server_spec])
- # Add --no-banner flag for dev command
- uv_cmd.append("--no-banner")
+ # 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"
@@ -322,7 +282,7 @@ async def dev(
[npx_cmd, inspector_cmd] + uv_cmd,
check=True,
shell=shell,
- env=dict(os.environ.items()) | env_vars,
+ env=env,
)
sys.exit(process.returncode)
except subprocess.CalledProcessError as e:
@@ -454,135 +414,74 @@ async def run(
Args:
server_spec: Python file, object specification (file:obj), config file, URL, or None to auto-detect
"""
- # Convert None to empty lists for list parameters
- with_packages = with_packages or []
- # Load configuration if needed
- from pathlib import Path
-
- from fastmcp.utilities.fastmcp_config import FastMCPConfig
-
- config = None
- config_path = None
- editable = None # Initialize editable variable
+ from fastmcp.utilities.cli import is_already_in_uv_subprocess, load_and_merge_config
- # Auto-detect fastmcp.json if no server_spec provided
- if server_spec is None:
- config_path = Path("fastmcp.json")
- if not config_path.exists():
- # Check if fastmcp.json exists in current directory
- found_config = FastMCPConfig.find_config()
- if found_config:
- config_path = found_config
- else:
- logger.error(
- "No server specification provided and no fastmcp.json found in current directory.\n"
- "Please specify a server file or create a fastmcp.json configuration."
- )
- sys.exit(1)
+ # Check if we were spawned by uv (or user explicitly set --skip-env)
+ if skip_env or is_already_in_uv_subprocess():
+ skip_env = True
- server_spec = str(config_path)
- logger.info(f"Using configuration from {config_path}")
+ try:
+ # Load config and apply CLI overrides
+ config, server_spec = load_and_merge_config(
+ server_spec,
+ python=python,
+ with_packages=with_packages or [],
+ with_requirements=with_requirements,
+ project=project,
+ transport=transport,
+ host=host,
+ port=port,
+ path=path,
+ log_level=log_level,
+ server_args=list(server_args) if server_args else None,
+ )
+ except FileNotFoundError:
+ sys.exit(1)
- # Load config if server_spec is a .json file
- if server_spec.endswith(".json"):
- config_path = Path(server_spec)
- if config_path.exists():
- # Try to load as JSON and discriminate between FastMCPConfig and MCPConfig
- try:
- with open(config_path) as f:
- data = json.load(f)
+ # Get effective values (CLI overrides take precedence)
+ final_transport = transport or config.deployment.transport
+ final_host = host or config.deployment.host
+ final_port = port or config.deployment.port
+ 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
- # Check if it's an MCPConfig first (has canonical mcpServers key)
- if "mcpServers" in data:
- # It's an MCPConfig, we don't process these in the run command
- # They should be handled through different code paths
- config = None
- else:
- # Try to parse as FastMCPConfig
- try:
- adapter = get_cached_typeadapter(FastMCPConfig)
- config = adapter.validate_python(data)
-
- # Merge deployment config with CLI values (CLI takes precedence)
- if config.deployment:
- transport = transport or config.deployment.transport
- host = host or config.deployment.host
- port = port or config.deployment.port
- path = path or config.deployment.path
- log_level = log_level or config.deployment.log_level
- server_args = (
- tuple(server_args)
- if server_args
- else tuple(config.deployment.args or ())
- )
-
- # Merge environment config with CLI values (CLI takes precedence)
- # BUT: Skip this if --skip-env is set
- if config.environment and not skip_env:
- python = python or config.environment.python
- project = project or (
- Path(config.environment.project)
- if config.environment.project
- else None
- )
- with_requirements = with_requirements or (
- Path(config.environment.requirements)
- if config.environment.requirements
- else None
- )
- # Extract editable from config (no CLI override for this)
- editable = config.environment.editable
-
- # Merge packages from both sources
- if config.environment.dependencies:
- packages = list(config.environment.dependencies)
- if with_packages:
- packages.extend(with_packages)
- with_packages = packages
- except ValidationError:
- # Not a valid FastMCPConfig, treat as regular server spec
- config = None
- except (json.JSONDecodeError, FileNotFoundError):
- # Not a valid JSON file, treat as regular server spec
- config = None
- else:
- config = None
logger.debug(
"Running server or client",
extra={
"server_spec": server_spec,
- "transport": transport,
- "host": host,
- "port": port,
- "path": path,
- "log_level": log_level,
- "server_args": list(server_args),
+ "transport": final_transport,
+ "host": final_host,
+ "port": final_port,
+ "path": final_path,
+ "log_level": final_log_level,
+ "server_args": list(final_server_args) if final_server_args else [],
},
)
- # Check if we need to use uv run (either from CLI args or config)
- # When --skip-env is set, we ignore config.environment entirely
- needs_uv = python or with_packages or with_requirements or project or editable
- if not needs_uv and config and config.environment and not skip_env:
- # Check if config's environment needs uv (but only if not skipping env)
- needs_uv = config.environment.needs_uv()
+ # Check if we need to use uv run (but skip if we're already in uv or user said to skip)
+ needs_uv = config.environment.needs_uv() and not skip_env
if needs_uv:
# Use uv run subprocess - always use run_with_uv which handles output correctly
try:
run_module.run_with_uv(
server_spec=server_spec,
- python_version=python,
- with_packages=with_packages,
- with_requirements=with_requirements,
- project=project,
- transport=transport,
- host=host,
- port=port,
- path=path,
- log_level=log_level,
+ 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=editable,
+ editable=config.environment.editable,
)
except Exception as e:
logger.error(
@@ -598,12 +497,12 @@ async def run(
try:
await run_module.run_command(
server_spec=server_spec,
- transport=transport,
- host=host,
- port=port,
- path=path,
- log_level=log_level,
- server_args=list(server_args),
+ transport=final_transport,
+ host=final_host,
+ port=final_port,
+ path=final_path,
+ log_level=final_log_level,
+ server_args=list(final_server_args) if final_server_args else [],
show_banner=not no_banner,
skip_source=skip_source,
)
@@ -696,100 +595,47 @@ async def inspect(
Args:
server_spec: Python file to inspect, optionally with :object suffix, or fastmcp.json
"""
- # Convert None to empty lists for list parameters
- with_packages = with_packages or []
- config = None
- config_path = None
-
- # Auto-detect fastmcp.json if no server_spec provided
- if server_spec is None:
- config_path = Path("fastmcp.json")
- if not config_path.exists():
- # Check if fastmcp.json exists in current directory
- found_config = FastMCPConfig.find_config()
- if found_config:
- config_path = found_config
- else:
- logger.error(
- "No server specification provided and no fastmcp.json found in current directory.\n"
- "Please specify a server file or create a fastmcp.json configuration."
- )
- sys.exit(1)
+ from fastmcp.utilities.cli import is_already_in_uv_subprocess, load_and_merge_config
- server_spec = str(config_path)
- logger.info(f"Using configuration from {config_path}")
+ # Check if we were spawned by uv (or user explicitly set --skip-env)
+ if skip_env or is_already_in_uv_subprocess():
+ skip_env = True
+
+ try:
+ # Load config and apply CLI overrides
+ config, server_spec = load_and_merge_config(
+ server_spec,
+ python=python,
+ with_packages=with_packages or [],
+ with_requirements=with_requirements,
+ project=project,
+ )
- # Create FastMCPConfig from server_spec
- if server_spec.endswith(".json"):
- config_path = Path(server_spec)
- if config_path.exists():
+ # Check if it's an MCPConfig (which inspect doesn't support)
+ if server_spec.endswith(".json") and config is None:
+ # This might be an MCPConfig, check the file
try:
- with open(config_path) as f:
+ with open(Path(server_spec)) as f:
data = json.load(f)
-
- # Check if it's an MCPConfig (has mcpServers key)
if "mcpServers" in data:
- # MCPConfig - we don't process these in inspect
logger.error("MCPConfig files are not supported by inspect command")
sys.exit(1)
- else:
- # It's a FastMCPConfig
- config = FastMCPConfig.from_file(config_path)
-
- # Merge environment settings from config with CLI (CLI takes precedence)
- if config.environment:
- python = python or config.environment.python
- project = project or (
- Path(config.environment.project)
- if config.environment.project
- else None
- )
- with_requirements = with_requirements or (
- Path(config.environment.requirements)
- if config.environment.requirements
- else None
- )
-
- # Merge packages from both sources
- if config.environment.dependencies:
- packages = list(config.environment.dependencies)
- if with_packages:
- packages.extend(with_packages)
- with_packages = packages
- except (json.JSONDecodeError, ValidationError) as e:
- logger.error(f"Invalid configuration file: {e}")
- sys.exit(1)
- else:
- logger.error(f"Configuration file not found: {config_path}")
- sys.exit(1)
- else:
- # Create config from file path
- source = FileSystemSource(path=server_spec)
- config = FastMCPConfig(source=source)
+ except (json.JSONDecodeError, FileNotFoundError):
+ pass
+
+ except FileNotFoundError:
+ sys.exit(1)
- # Check if we need to use uv run (skip if --skip-env is set)
- needs_uv = False
- if not skip_env:
- needs_uv = python or with_packages or with_requirements or project
- if not needs_uv and config and config.environment:
- needs_uv = config.environment.needs_uv()
+ # Check if we need to use uv run (but skip if we're already in uv or user said to skip)
+ needs_uv = config.environment.needs_uv() and not skip_env
if needs_uv:
# Build and run uv command
-
- # Create or update environment config
- env_config = Environment(
- python=python,
- dependencies=with_packages if with_packages else None,
- requirements=str(with_requirements) if with_requirements else None,
- project=str(project) if project else None,
- )
-
+ # The environment is already configured in the config object
inspect_command = [
"fastmcp",
"inspect",
server_spec,
- "--skip-env", # Prevent infinite loop when calling through uv
]
# Add format and output flags if specified
@@ -797,7 +643,7 @@ async def inspect(
inspect_command.extend(["--format", format.value])
if output:
inspect_command.extend(["--output", str(output)])
- env_config.run_with_uv(inspect_command)
+ config.environment.run_with_uv(inspect_command)
return # run_with_uv exits the process
logger.debug(
@@ -811,6 +657,10 @@ async def inspect(
try:
# Load the server using the config
+ if not config:
+ logger.error("No configuration available")
+ sys.exit(1)
+ assert config is not None # For type checker
server = await config.source.load_server()
# Get basic server information
@@ -936,8 +786,6 @@ async def prepare(
"""
from pathlib import Path
- from fastmcp.utilities.fastmcp_config import FastMCPConfig
-
# Require output-dir
if output_dir is None:
logger.error(
diff --git a/src/fastmcp/cli/install/claude_code.py b/src/fastmcp/cli/install/claude_code.py
index aaa07503c..0117f67b4 100644
--- a/src/fastmcp/cli/install/claude_code.py
+++ b/src/fastmcp/cli/install/claude_code.py
@@ -115,7 +115,7 @@ def install_claude_code(
if not deduplicated_packages:
deduplicated_packages = None
- # Build uv run command using Environment.build_uv_args()
+ # Build uv run command using Environment.build_uv_run_command()
env_config = Environment(
python=python_version,
dependencies=deduplicated_packages,
@@ -123,7 +123,6 @@ def install_claude_code(
project=str(project) if project else None,
editable=[str(p) for p in with_editable] if with_editable else None,
)
- args = env_config.build_uv_args()
# Build server spec from parsed components
if server_object:
@@ -131,8 +130,8 @@ def install_claude_code(
else:
server_spec = str(file.resolve())
- # Add fastmcp run command
- args.extend(["fastmcp", "run", server_spec])
+ # Build the full command
+ full_command = env_config.build_uv_run_command(["fastmcp", "run", server_spec])
# Build claude mcp add command
cmd_parts = [claude_cmd, "mcp", "add"]
@@ -144,7 +143,7 @@ def install_claude_code(
# Add server name and command
cmd_parts.extend([name, "--"])
- cmd_parts.extend(["uv"] + args)
+ cmd_parts.extend(full_command)
try:
# Run the claude mcp add command
diff --git a/src/fastmcp/cli/install/claude_desktop.py b/src/fastmcp/cli/install/claude_desktop.py
index 28ce20eee..d4184f95d 100644
--- a/src/fastmcp/cli/install/claude_desktop.py
+++ b/src/fastmcp/cli/install/claude_desktop.py
@@ -88,21 +88,19 @@ def install_claude_desktop(
project=str(project) if project else None,
editable=[str(p) for p in with_editable] if with_editable else None,
)
- args = env_config.build_uv_args()
-
# 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 the full command
+ full_command = env_config.build_uv_run_command(["fastmcp", "run", server_spec])
# Create server configuration
server_config = StdioMCPServer(
- command="uv",
- args=args,
+ command=full_command[0],
+ args=full_command[1:],
env=env_vars or {},
)
diff --git a/src/fastmcp/cli/install/cursor.py b/src/fastmcp/cli/install/cursor.py
index bbb94a872..f10192e16 100644
--- a/src/fastmcp/cli/install/cursor.py
+++ b/src/fastmcp/cli/install/cursor.py
@@ -122,21 +122,19 @@ def install_cursor_workspace(
project=str(project.resolve()) if project else None,
editable=[str(p.resolve()) for p in with_editable] if with_editable else None,
)
- args = env_config.build_uv_args()
-
# 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 the full command
+ full_command = env_config.build_uv_run_command(["fastmcp", "run", server_spec])
# Create server configuration
server_config = StdioMCPServer(
- command="uv",
- args=args,
+ command=full_command[0],
+ args=full_command[1:],
env=env_vars or {},
)
@@ -202,16 +200,14 @@ def install_cursor(
project=str(project.resolve()) if project else None,
editable=[str(p.resolve()) for p in with_editable] if with_editable else None,
)
- args = env_config.build_uv_args()
-
# 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 the full command
+ full_command = env_config.build_uv_run_command(["fastmcp", "run", server_spec])
# If workspace is specified, install to workspace-specific config
if workspace:
@@ -230,8 +226,8 @@ def install_cursor(
# Create server configuration
server_config = StdioMCPServer(
- command="uv",
- args=args,
+ command=full_command[0],
+ args=full_command[1:],
env=env_vars or {},
)
diff --git a/src/fastmcp/cli/install/mcp_json.py b/src/fastmcp/cli/install/mcp_json.py
index 42696ae6c..5ea466590 100644
--- a/src/fastmcp/cli/install/mcp_json.py
+++ b/src/fastmcp/cli/install/mcp_json.py
@@ -63,21 +63,19 @@ def install_mcp_json(
project=str(project) if project else None,
editable=[str(p) for p in with_editable] if with_editable else None,
)
- args = env_config.build_uv_args()
-
# 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 the full command
+ full_command = env_config.build_uv_run_command(["fastmcp", "run", server_spec])
# Build MCP server configuration
server_config = {
- "command": "uv",
- "args": args,
+ "command": full_command[0],
+ "args": full_command[1:],
}
# Add environment variables if provided
diff --git a/src/fastmcp/cli/install/shared.py b/src/fastmcp/cli/install/shared.py
index 6db83403f..54b61977d 100644
--- a/src/fastmcp/cli/install/shared.py
+++ b/src/fastmcp/cli/install/shared.py
@@ -62,9 +62,9 @@ async def process_common_args(
config = FastMCPConfig.from_file(config_path)
# Merge packages from config if not overridden
- if config.environment and config.environment.dependencies:
+ if config.environment.dependencies:
# Merge with CLI packages (CLI takes precedence)
- config_packages = list(config.environment.dependencies) or []
+ config_packages = list(config.environment.dependencies)
with_packages = list(set(with_packages + config_packages))
except (json.JSONDecodeError, ValidationError) as e:
print(f"[red]Invalid configuration file: {e}[/red]")
diff --git a/src/fastmcp/cli/run.py b/src/fastmcp/cli/run.py
index 47302f210..2b812e625 100644
--- a/src/fastmcp/cli/run.py
+++ b/src/fastmcp/cli/run.py
@@ -1,6 +1,7 @@
"""FastMCP run command implementation with enhanced type hints."""
import json
+import os
import re
import subprocess
import sys
@@ -8,7 +9,6 @@ from pathlib import Path
from typing import Any, Literal
from mcp.server.fastmcp import FastMCP as FastMCP1x
-from pydantic import ValidationError
from fastmcp.server.server import FastMCP
from fastmcp.utilities.fastmcp_config import (
@@ -17,7 +17,6 @@ from fastmcp.utilities.fastmcp_config import (
)
from fastmcp.utilities.fastmcp_config.v1.sources.filesystem import FileSystemSource
from fastmcp.utilities.logging import get_logger
-from fastmcp.utilities.types import get_cached_typeadapter
logger = get_logger("cli.run")
@@ -48,6 +47,10 @@ def run_with_uv(
) -> 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")
@@ -60,70 +63,10 @@ def run_with_uv(
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
"""
- # Check if server_spec is a .json file
- if server_spec.endswith(".json"):
- config_path = Path(server_spec).resolve() # Get absolute path
- if config_path.exists():
- # Try to load as JSON and discriminate between FastMCPConfig and MCPConfig
- try:
- with open(config_path) as f:
- data = json.load(f)
-
- # Check if it's an MCPConfig first (has canonical mcpServers key)
- if "mcpServers" in data:
- # It's an MCPConfig, we don't process it here - just pass through
- pass
- else:
- # Try to parse as FastMCPConfig
- try:
- adapter = get_cached_typeadapter(FastMCPConfig)
- config: FastMCPConfig = adapter.validate_python(data)
-
- # Apply deployment settings
- if config.deployment:
- config.deployment.apply_runtime_settings(config_path)
-
- # Merge environment config with CLI args (CLI takes precedence)
- if config.environment:
- # Use CLI values if provided, otherwise fall back to config
- python_version = python_version or config.environment.python
- project = project or (
- Path(config.environment.project)
- if config.environment.project
- else None
- )
- with_requirements = with_requirements or (
- Path(config.environment.requirements)
- if config.environment.requirements
- else None
- )
- # Note: config editable is a list but CLI currently only supports single path
- # Just pass through for now - Environment will handle the list
- if not editable and config.environment.editable:
- editable = config.environment.editable
-
- # Merge packages from both sources
- # Only merge if with_packages doesn't already contain them
- # (they may have been merged already in CLI)
- if config.environment.dependencies and not with_packages:
- with_packages = list(config.environment.dependencies)
-
- # Merge deployment config with CLI args (CLI takes precedence)
- if config.deployment:
- transport = transport or config.deployment.transport
- host = host or config.deployment.host
- port = port or config.deployment.port
- path = path or config.deployment.path
- log_level = log_level or config.deployment.log_level
- except ValidationError:
- # Not a valid FastMCPConfig, just pass through
- pass
- except (json.JSONDecodeError, FileNotFoundError):
- # Not a valid JSON file, just pass through
- pass
-
- # Build uv command using Environment.build_uv_args()
+
+ # Build uv command using Environment.build_uv_run_command()
env_config = Environment(
python=python_version,
dependencies=with_packages if with_packages else None,
@@ -133,9 +76,9 @@ def run_with_uv(
if isinstance(editable, list)
else ([editable] if editable else None),
)
- # Build the uv command
- # Build the inner fastmcp command with --skip-env to prevent infinite recursion
- inner_cmd = ["fastmcp", "run", "--skip-env", server_spec]
+
+ # 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:
@@ -154,13 +97,15 @@ def run_with_uv(
inner_cmd.append("--no-banner")
# Build the full uv command
- uv_args = env_config.build_uv_args(inner_cmd)
- cmd = ["uv"] + uv_args
+ cmd = env_config.build_uv_run_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)
+ 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}")
@@ -210,8 +155,7 @@ def load_fastmcp_config(config_path: Path) -> FastMCPConfig:
config = FastMCPConfig.from_file(config_path)
# Apply runtime settings from deployment config
- if config.deployment:
- config.deployment.apply_runtime_settings(config_path)
+ config.deployment.apply_runtime_settings(config_path)
return config
@@ -263,15 +207,14 @@ async def run_command(
config = load_fastmcp_config(config_path)
# Merge deployment config with CLI arguments (CLI takes precedence)
- if config.deployment:
- transport = transport or config.deployment.transport
- host = host or config.deployment.host
- port = port or config.deployment.port
- path = path or config.deployment.path
- log_level = log_level or config.deployment.log_level
- server_args = (
- server_args if server_args is not None else config.deployment.args
- )
+ transport = transport or config.deployment.transport
+ host = host or config.deployment.host
+ port = port or config.deployment.port
+ path = path or config.deployment.path
+ log_level = log_level or config.deployment.log_level
+ server_args = (
+ server_args if server_args is not None else config.deployment.args
+ )
# Prepare source only (environment is handled by uv run)
await config.prepare_source() if not skip_source else None
diff --git a/src/fastmcp/utilities/cli.py b/src/fastmcp/utilities/cli.py
index 1c208da4d..55081a5ad 100644
--- a/src/fastmcp/utilities/cli.py
+++ b/src/fastmcp/utilities/cli.py
@@ -1,8 +1,12 @@
from __future__ import annotations
+import json
+import os
from importlib.metadata import version
+from pathlib import Path
from typing import TYPE_CHECKING, Any, Literal
+from pydantic import ValidationError
from rich.align import Align
from rich.console import Console, Group
from rich.panel import Panel
@@ -10,10 +14,130 @@ from rich.table import Table
from rich.text import Text
import fastmcp
+from fastmcp.utilities.fastmcp_config import FastMCPConfig
+from fastmcp.utilities.fastmcp_config.v1.sources.filesystem import FileSystemSource
+from fastmcp.utilities.logging import get_logger
+from fastmcp.utilities.types import get_cached_typeadapter
if TYPE_CHECKING:
from fastmcp import FastMCP
+logger = get_logger("cli.config")
+
+
+def is_already_in_uv_subprocess() -> bool:
+ """Check if we're already running in a FastMCP uv subprocess."""
+ return bool(os.environ.get("FASTMCP_UV_SPAWNED"))
+
+
+def load_and_merge_config(
+ server_spec: str | None,
+ **cli_overrides,
+) -> tuple[FastMCPConfig, str]:
+ """Load config from server_spec and apply CLI overrides.
+
+ This consolidates the config parsing logic that was duplicated across
+ run, inspect, and dev commands.
+
+ Args:
+ server_spec: Python file, config file, URL, or None to auto-detect
+ cli_overrides: CLI arguments that override config values
+
+ Returns:
+ Tuple of (FastMCPConfig, resolved_server_spec)
+ """
+ config = None
+ config_path = None
+
+ # Auto-detect fastmcp.json if no server_spec provided
+ if server_spec is None:
+ config_path = Path("fastmcp.json")
+ if not config_path.exists():
+ found_config = FastMCPConfig.find_config()
+ if found_config:
+ config_path = found_config
+ else:
+ logger.error(
+ "No server specification provided and no fastmcp.json found in current directory.\n"
+ "Please specify a server file or create a fastmcp.json configuration."
+ )
+ raise FileNotFoundError("No server specification or fastmcp.json found")
+
+ resolved_spec = str(config_path)
+ logger.info(f"Using configuration from {config_path}")
+ else:
+ resolved_spec = server_spec
+
+ # Load config if server_spec is a .json file
+ if resolved_spec.endswith(".json"):
+ config_path = Path(resolved_spec)
+ if config_path.exists():
+ try:
+ with open(config_path) as f:
+ data = json.load(f)
+
+ # Check if it's an MCPConfig first (has canonical mcpServers key)
+ if "mcpServers" in data:
+ # MCPConfig - we don't process these here, just pass through
+ pass
+ else:
+ # Try to parse as FastMCPConfig
+ try:
+ adapter = get_cached_typeadapter(FastMCPConfig)
+ config = adapter.validate_python(data)
+
+ # Apply deployment settings
+ if config.deployment:
+ config.deployment.apply_runtime_settings(config_path)
+
+ except ValidationError:
+ # Not a valid FastMCPConfig, just pass through
+ pass
+ except (json.JSONDecodeError, FileNotFoundError):
+ # Not a valid JSON file, just pass through
+ pass
+
+ # If we don't have a config object yet, create one from filesystem source
+ if config is None:
+ source = FileSystemSource(path=resolved_spec)
+ config = FastMCPConfig(source=source)
+
+ # Convert to dict for immutable transformation
+ config_dict = config.model_dump()
+
+ # Apply CLI overrides to config's environment (always exists due to default_factory)
+ if python_override := cli_overrides.get("python"):
+ config_dict["environment"]["python"] = python_override
+ if packages_override := cli_overrides.get("with_packages"):
+ # Merge packages - CLI packages are added to config packages
+ existing = config_dict["environment"].get("dependencies") or []
+ config_dict["environment"]["dependencies"] = packages_override + existing
+ if requirements_override := cli_overrides.get("with_requirements"):
+ config_dict["environment"]["requirements"] = str(requirements_override)
+ if project_override := cli_overrides.get("project"):
+ config_dict["environment"]["project"] = str(project_override)
+ if editable_override := cli_overrides.get("editable"):
+ config_dict["environment"]["editable"] = editable_override
+
+ # Apply deployment CLI overrides (always exists due to default_factory)
+ if transport_override := cli_overrides.get("transport"):
+ config_dict["deployment"]["transport"] = transport_override
+ if host_override := cli_overrides.get("host"):
+ config_dict["deployment"]["host"] = host_override
+ if port_override := cli_overrides.get("port"):
+ config_dict["deployment"]["port"] = port_override
+ if path_override := cli_overrides.get("path"):
+ config_dict["deployment"]["path"] = path_override
+ if log_level_override := cli_overrides.get("log_level"):
+ config_dict["deployment"]["log_level"] = log_level_override
+ if server_args_override := cli_overrides.get("server_args"):
+ config_dict["deployment"]["args"] = server_args_override
+
+ # Create new config from modified dict
+ new_config = FastMCPConfig(**config_dict)
+ return new_config, resolved_spec
+
+
LOGO_ASCII = r"""
_ __ ___ _____ __ __ _____________ ____ ____
_ __ ___ .'____/___ ______/ /_/ |/ / ____/ __ \ |___ \ / __ \
diff --git a/src/fastmcp/utilities/fastmcp_config/v1/fastmcp_config.py b/src/fastmcp/utilities/fastmcp_config/v1/fastmcp_config.py
index 4fb197cbc..01cd1b846 100644
--- a/src/fastmcp/utilities/fastmcp_config/v1/fastmcp_config.py
+++ b/src/fastmcp/utilities/fastmcp_config/v1/fastmcp_config.py
@@ -63,16 +63,16 @@ class Environment(BaseModel):
examples=[[".", "../my-package"], ["/path/to/package"]],
)
- def build_uv_args(self, command: str | list[str] | None = None) -> list[str]:
- """Build uv run arguments from this environment configuration.
+ def build_uv_run_command(self, command: list[str]) -> list[str]:
+ """Build complete uv run command with environment args and command to execute.
Args:
- command: Optional command to append (string or list of args)
+ command: Command to execute (e.g., ["fastmcp", "run", "server.py"])
Returns:
- List of arguments for uv run command
+ Complete command ready for subprocess.run, including "uv" prefix
"""
- args = ["run"]
+ args = ["uv", "run"]
# Add project if specified
if self.project:
@@ -97,12 +97,8 @@ class Environment(BaseModel):
for editable_path in self.editable:
args.extend(["--with-editable", str(editable_path)])
- # Add the command if provided
- if command:
- if isinstance(command, str):
- args.append(command)
- else:
- args.extend(command)
+ # Add the command
+ args.extend(command)
return args
@@ -116,14 +112,16 @@ class Environment(BaseModel):
import sys
# Build the full uv command
- uv_args = self.build_uv_args(command)
- cmd = ["uv"] + uv_args
+ cmd = self.build_uv_run_command(command)
+
+ # Set marker to prevent infinite loops when subprocess calls FastMCP again
+ env = os.environ | {"FASTMCP_UV_SPAWNED": "1"}
logger.debug(f"Running command: {' '.join(cmd)}")
try:
# Run without capturing output so it flows through naturally
- process = subprocess.run(cmd, check=True)
+ process = subprocess.run(cmd, check=True, env=env)
sys.exit(process.returncode)
except subprocess.CalledProcessError as e:
logger.error(f"Command failed: {e}")
diff --git a/tests/cli/test_config.py b/tests/cli/test_config.py
index 094b9bc52..ec8b413c1 100644
--- a/tests/cli/test_config.py
+++ b/tests/cli/test_config.py
@@ -92,8 +92,8 @@ class TestEnvironment:
)
assert config.environment.needs_uv()
- def test_build_uv_args(self):
- """Test build_uv_args() method."""
+ def test_build_uv_run_command(self):
+ """Test build_uv_run_command() method."""
config = FastMCPConfig(
source={"path": "server.py"},
environment={
@@ -104,23 +104,24 @@ class TestEnvironment:
},
)
- args = config.environment.build_uv_args(["fastmcp", "run", "server.py"])
+ cmd = config.environment.build_uv_run_command(["fastmcp", "run", "server.py"])
- assert args[0] == "run"
+ assert cmd[0] == "uv"
+ assert cmd[1] == "run"
# Python version not added when project is specified (project defines its own Python)
- assert "--python" not in args
- assert "3.12" not in args
- assert "--project" in args
- assert "." in args
- assert "--with" in args
- assert "requests" in args
- assert "numpy" in args
- assert "--with-requirements" in args
- assert "requirements.txt" in args
+ assert "--python" not in cmd
+ assert "3.12" not in cmd
+ assert "--project" in cmd
+ assert "." in cmd
+ assert "--with" in cmd
+ assert "requests" in cmd
+ assert "numpy" in cmd
+ assert "--with-requirements" in cmd
+ assert "requirements.txt" in cmd
# Command args should be at the end
- assert "fastmcp" in args[-3:]
- assert "run" in args[-2:]
- assert "server.py" in args[-1:]
+ assert "fastmcp" in cmd[-3:]
+ assert "run" in cmd[-2:]
+ assert "server.py" in cmd[-1:]
def test_run_with_uv(self):
"""Test run_with_uv() subprocess execution."""
diff --git a/tests/cli/test_fastmcp_config_integration.py b/tests/cli/test_fastmcp_config_integration.py
index 98070385f..800b23b08 100644
--- a/tests/cli/test_fastmcp_config_integration.py
+++ b/tests/cli/test_fastmcp_config_integration.py
@@ -227,14 +227,14 @@ class TestPathResolution:
environment={"requirements": "requirements.txt"}, # type: ignore[arg-type]
)
- # Build UV args
+ # Build UV command
assert config.environment is not None
- uv_args = config.environment.build_uv_args(["fastmcp", "run"])
+ uv_cmd = config.environment.build_uv_run_command(["fastmcp", "run"])
# Should include requirements file
- assert "--with-requirements" in uv_args
- req_idx = uv_args.index("--with-requirements") + 1
- assert uv_args[req_idx] == "requirements.txt"
+ assert "--with-requirements" in uv_cmd
+ req_idx = uv_cmd.index("--with-requirements") + 1
+ assert uv_cmd[req_idx] == "requirements.txt"
class TestConfigValidation:
diff --git a/tests/cli/test_run_config.py b/tests/cli/test_run_config.py
index 5ef7c26e1..07443414f 100644
--- a/tests/cli/test_run_config.py
+++ b/tests/cli/test_run_config.py
@@ -261,13 +261,11 @@ def test_environment_config_path_resolution(tmp_path):
config = load_fastmcp_config(config_file)
- # Check that UV args are built with resolved paths
- uv_args = config.environment.build_uv_args(["fastmcp", "run", "server.py"])
+ # Check that UV command is built with resolved paths
+ uv_cmd = config.environment.build_uv_run_command(["fastmcp", "run", "server.py"])
- assert "--with-requirements" in uv_args
- assert "--project" in uv_args
+ assert "--with-requirements" in uv_cmd
+ assert "--project" in uv_cmd
# Path should be resolved relative to config file
- req_idx = uv_args.index("--with-requirements") + 1
- assert (
- Path(uv_args[req_idx]).is_absolute() or uv_args[req_idx] == "requirements.txt"
- )
+ req_idx = uv_cmd.index("--with-requirements") + 1
+ assert Path(uv_cmd[req_idx]).is_absolute() or uv_cmd[req_idx] == "requirements.txt"
diff --git a/tests/cli/test_run_with_uv.py b/tests/cli/test_run_with_uv.py
index 027939191..446b21787 100644
--- a/tests/cli/test_run_with_uv.py
+++ b/tests/cli/test_run_with_uv.py
@@ -25,16 +25,18 @@ class TestRunWithUv:
# Check the command that was called
mock_run.assert_called_once()
cmd = mock_run.call_args[0][0]
+ env = mock_run.call_args.kwargs.get("env", {})
expected = [
"uv",
"run",
"fastmcp",
"run",
- "--skip-env",
"server.py",
]
assert cmd == expected
+ # Check that the environment marker is set
+ assert env.get("FASTMCP_UV_SPAWNED") == "1"
@patch("subprocess.run")
def test_run_with_uv_python_version(self, mock_run):
@@ -54,7 +56,6 @@ class TestRunWithUv:
"3.11",
"fastmcp",
"run",
- "--skip-env",
"server.py",
]
assert cmd == expected
@@ -80,7 +81,6 @@ class TestRunWithUv:
assert cmd[4:] == [
"fastmcp",
"run",
- "--skip-env",
"server.py",
]
@@ -104,7 +104,6 @@ class TestRunWithUv:
"numpy", # original order preserved
"fastmcp",
"run",
- "--skip-env",
"server.py",
]
assert cmd == expected
@@ -128,7 +127,6 @@ class TestRunWithUv:
str(req_path.resolve()), # auto-resolved to absolute path
"fastmcp",
"run",
- "--skip-env",
"server.py",
]
assert cmd == expected
@@ -157,7 +155,6 @@ class TestRunWithUv:
"run",
"fastmcp",
"run",
- "--skip-env",
"server.py",
"--transport",
"http",
@@ -220,7 +217,6 @@ class TestRunWithUv:
assert cmd[next_idx:] == [
"fastmcp",
"run",
- "--skip-env",
"server.py",
"--transport",
"http",
diff --git a/tests/utilities/test_cli.py b/tests/utilities/test_cli.py
index bcb45f664..cd8b55dcb 100644
--- a/tests/utilities/test_cli.py
+++ b/tests/utilities/test_cli.py
@@ -3,22 +3,23 @@
from fastmcp.utilities.fastmcp_config.v1.fastmcp_config import Environment
-class TestEnvironmentBuildUVArgs:
- """Test the Environment.build_uv_args() method."""
+class TestEnvironmentBuildUVRunCommand:
+ """Test the Environment.build_uv_run_command() method."""
- def test_build_uv_args_basic(self):
- """Test building basic uv args with no environment config."""
+ def test_build_uv_run_command_basic(self):
+ """Test building basic uv command with no environment config."""
env = Environment()
- args = env.build_uv_args(["fastmcp", "run", "server.py"])
- expected = ["run", "fastmcp", "run", "server.py"]
- assert args == expected
+ cmd = env.build_uv_run_command(["fastmcp", "run", "server.py"])
+ expected = ["uv", "run", "fastmcp", "run", "server.py"]
+ assert cmd == expected
- def test_build_uv_args_with_editable(self):
- """Test building uv args with editable package."""
+ def test_build_uv_run_command_with_editable(self):
+ """Test building uv command with editable package."""
editable_path = "/path/to/package"
env = Environment(editable=[editable_path])
- args = env.build_uv_args(["fastmcp", "run", "server.py"])
+ cmd = env.build_uv_run_command(["fastmcp", "run", "server.py"])
expected = [
+ "uv",
"run",
"--with-editable",
editable_path,
@@ -26,13 +27,14 @@ class TestEnvironmentBuildUVArgs:
"run",
"server.py",
]
- assert args == expected
+ assert cmd == expected
- def test_build_uv_args_with_packages(self):
- """Test building uv args with additional packages."""
+ def test_build_uv_run_command_with_packages(self):
+ """Test building uv command with additional packages."""
env = Environment(dependencies=["pkg1", "pkg2"])
- args = env.build_uv_args(["fastmcp", "run", "server.py"])
+ cmd = env.build_uv_run_command(["fastmcp", "run", "server.py"])
expected = [
+ "uv",
"run",
"--with",
"pkg1",
@@ -42,13 +44,14 @@ class TestEnvironmentBuildUVArgs:
"run",
"server.py",
]
- assert args == expected
+ assert cmd == expected
- def test_build_uv_args_with_python_version(self):
- """Test building uv args with Python version."""
+ def test_build_uv_run_command_with_python_version(self):
+ """Test building uv command with Python version."""
env = Environment(python="3.10")
- args = env.build_uv_args(["fastmcp", "run", "server.py"])
+ cmd = env.build_uv_run_command(["fastmcp", "run", "server.py"])
expected = [
+ "uv",
"run",
"--python",
"3.10",
@@ -56,14 +59,15 @@ class TestEnvironmentBuildUVArgs:
"run",
"server.py",
]
- assert args == expected
+ assert cmd == expected
- def test_build_uv_args_with_requirements(self):
- """Test building uv args with requirements file."""
+ def test_build_uv_run_command_with_requirements(self):
+ """Test building uv command with requirements file."""
requirements_path = "/path/to/requirements.txt"
env = Environment(requirements=requirements_path)
- args = env.build_uv_args(["fastmcp", "run", "server.py"])
+ cmd = env.build_uv_run_command(["fastmcp", "run", "server.py"])
expected = [
+ "uv",
"run",
"--with-requirements",
requirements_path,
@@ -71,18 +75,26 @@ class TestEnvironmentBuildUVArgs:
"run",
"server.py",
]
- assert args == expected
+ assert cmd == expected
- def test_build_uv_args_with_project(self):
- """Test building uv args with project directory."""
+ def test_build_uv_run_command_with_project(self):
+ """Test building uv command with project directory."""
project_path = "/path/to/project"
env = Environment(project=project_path)
- args = env.build_uv_args(["fastmcp", "run", "server.py"])
- expected = ["run", "--project", project_path, "fastmcp", "run", "server.py"]
- assert args == expected
+ cmd = env.build_uv_run_command(["fastmcp", "run", "server.py"])
+ expected = [
+ "uv",
+ "run",
+ "--project",
+ project_path,
+ "fastmcp",
+ "run",
+ "server.py",
+ ]
+ assert cmd == expected
- def test_build_uv_args_with_everything(self):
- """Test building uv args with all options."""
+ def test_build_uv_run_command_with_everything(self):
+ """Test building uv command with all options."""
requirements_path = "/path/to/requirements.txt"
editable_path = "/local/pkg"
env = Environment(
@@ -91,8 +103,9 @@ class TestEnvironmentBuildUVArgs:
requirements=requirements_path,
editable=[editable_path],
)
- args = env.build_uv_args(["fastmcp", "run", "server.py"])
+ cmd = env.build_uv_run_command(["fastmcp", "run", "server.py"])
expected = [
+ "uv",
"run",
"--python",
"3.10",
@@ -108,23 +121,12 @@ class TestEnvironmentBuildUVArgs:
"run",
"server.py",
]
- assert args == expected
+ assert cmd == expected
- def test_build_uv_args_no_command(self):
- """Test building uv args without command."""
- env = Environment(dependencies=["pkg1"])
- args = env.build_uv_args()
- expected = ["run", "--with", "pkg1"]
- assert args == expected
-
- def test_build_uv_args_with_string_command(self):
- """Test building uv args with string command."""
- env = Environment()
- args = env.build_uv_args("python")
- expected = ["run", "python"]
- assert args == expected
+ # Note: These tests are removed because build_uv_run_command now requires a command
+ # and only accepts a list, not optional or string commands
- def test_build_uv_args_project_with_extras(self):
+ def test_build_uv_run_command_project_with_extras(self):
"""Test that project flag works with additional dependencies."""
project_path = "/path/to/project"
env = Environment(
@@ -133,8 +135,9 @@ class TestEnvironmentBuildUVArgs:
dependencies=["pandas"], # Should be added on top of project
editable=["/pkg"], # Should be added on top of project
)
- args = env.build_uv_args(["fastmcp", "run", "server.py"])
+ cmd = env.build_uv_run_command(["fastmcp", "run", "server.py"])
expected = [
+ "uv",
"run",
"--project",
project_path,
@@ -146,7 +149,7 @@ class TestEnvironmentBuildUVArgs:
"run",
"server.py",
]
- assert args == expected
+ assert cmd == expected
class TestEnvironmentNeedsUV: