universal-mcp 0.1.15rc7__py3-none-any.whl → 0.1.17__py3-none-any.whl

universal_mcp/applications/__init__.py

@@ -2,7 +2,7 @@ import importlib
 import os
 import subprocess
 import sys
-from importlib.metadata import version
+from pathlib import Path
 
 from loguru import logger
 
@@ -18,13 +18,13 @@ from universal_mcp.utils.common import (
     get_default_repository_path,
 )
 
-UNIVERSAL_MCP_HOME = os.path.join(os.path.expanduser("~"), ".universal-mcp", "packages")
+UNIVERSAL_MCP_HOME = Path.home() / ".universal-mcp" / "packages"
 
-if not os.path.exists(UNIVERSAL_MCP_HOME):
-    os.makedirs(UNIVERSAL_MCP_HOME)
+if not UNIVERSAL_MCP_HOME.exists():
+    UNIVERSAL_MCP_HOME.mkdir(parents=True, exist_ok=True)
 
 # set python path to include the universal-mcp home directory
-sys.path.append(UNIVERSAL_MCP_HOME)
+sys.path.append(str(UNIVERSAL_MCP_HOME))
 
 
 # Name are in the format of "app-name", eg, google-calendar
@@ -35,30 +35,34 @@ def _install_or_upgrade_package(package_name: str, repository_path: str):
     """
     Helper to install a package via pip from the universal-mcp GitHub repository.
     """
-    try:
-        current_version = version(package_name)
-        logger.info(f"Current version of {package_name} is {current_version}")
-    except ImportError:
-        current_version = None
-    if current_version is not None:
-        return
+
+    uv_path = os.getenv("UV_PATH")
+    uv_executable = str(Path(uv_path) / "uv") if uv_path else "uv"
+    logger.info(f"Using uv executable: {uv_executable}")
     cmd = [
-        "uv",
+        uv_executable,
         "pip",
         "install",
         "--upgrade",
         repository_path,
         "--target",
-        UNIVERSAL_MCP_HOME,
+        str(UNIVERSAL_MCP_HOME),
     ]
     logger.debug(f"Installing package '{package_name}' with command: {' '.join(cmd)}")
     try:
-        subprocess.check_call(cmd)
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.stdout:
+            logger.info(f"Command stdout: {result.stdout}")
+        if result.stderr:
+            logger.info(f"Command stderr: {result.stderr}")
+        result.check_returncode()
     except subprocess.CalledProcessError as e:
         logger.error(f"Installation failed for '{package_name}': {e}")
-        raise ModuleNotFoundError(
-            f"Installation failed for package '{package_name}'"
-        ) from e
+        if e.stdout:
+            logger.error(f"Command stdout: {e.stdout}")
+        if e.stderr:
+            logger.error(f"Command stderr: {e.stderr}")
+        raise ModuleNotFoundError(f"Installation failed for package '{package_name}'") from e
     else:
         logger.debug(f"Package {package_name} installed successfully")
 
@@ -72,9 +76,7 @@ def app_from_slug(slug: str):
     module_path = get_default_module_path(slug)
     package_name = get_default_package_name(slug)
     repository_path = get_default_repository_path(slug)
-    logger.debug(
-        f"Resolving app for slug '{slug}' → module '{module_path}', class '{class_name}'"
-    )
+    logger.debug(f"Resolving app for slug '{slug}' → module '{module_path}', class '{class_name}'")
     try:
         _install_or_upgrade_package(package_name, repository_path)
         module = importlib.import_module(module_path)
@@ -82,13 +84,9 @@ def app_from_slug(slug: str):
         logger.debug(f"Loaded class '{class_}' from module '{module_path}'")
         return class_
     except ModuleNotFoundError as e:
-        raise ModuleNotFoundError(
-            f"Package '{module_path}' not found locally. Please install it first."
-        ) from e
+        raise ModuleNotFoundError(f"Package '{module_path}' not found locally. Please install it first.") from e
     except AttributeError as e:
-        raise AttributeError(
-            f"Class '{class_name}' not found in module '{module_path}'"
-        ) from e
+        raise AttributeError(f"Class '{class_name}' not found in module '{module_path}'") from e
     except Exception as e:
         raise Exception(f"Error importing module '{module_path}': {e}") from e
 

universal_mcp/applications/application.py

@@ -82,11 +82,9 @@ class APIApplication(BaseApplication):
         super().__init__(name, **kwargs)
         self.default_timeout: int = 180
         self.integration: Integration | None = integration
-        logger.debug(
-            f"Initializing APIApplication '{name}' with integration: {integration}"
-        )
+        logger.debug(f"Initializing APIApplication '{name}' with integration: {integration}")
         self._client: httpx.Client | None = client
-        self.base_url: str = ""  # Initialize, but subclasses should set this
+        self.base_url: str = ""
 
     def _get_headers(self) -> dict[str, str]:
         """
@@ -112,11 +110,7 @@ class APIApplication(BaseApplication):
             return headers
 
         # Check if api key is provided
-        api_key = (
-            credentials.get("api_key")
-            or credentials.get("API_KEY")
-            or credentials.get("apiKey")
-        )
+        api_key = credentials.get("api_key") or credentials.get("API_KEY") or credentials.get("apiKey")
         if api_key:
             logger.debug("Using API key from credentials")
             return {
@@ -148,17 +142,11 @@ class APIApplication(BaseApplication):
         """
         if not self._client:
             headers = self._get_headers()
-            if not self.base_url:
-                logger.warning(f"APIApplication '{self.name}' base_url is not set.")
-                self._client = httpx.Client(
-                    headers=headers, timeout=self.default_timeout
-                )
-            else:
-                self._client = httpx.Client(
-                    base_url=self.base_url,
-                    headers=headers,
-                    timeout=self.default_timeout,
-                )
+            self._client = httpx.Client(
+                base_url=self.base_url,
+                headers=headers,
+                timeout=self.default_timeout,
+            )
         return self._client
 
     def _get(self, url: str, params: dict[str, Any] | None = None) -> httpx.Response:
@@ -181,9 +169,7 @@ class APIApplication(BaseApplication):
         logger.debug(f"GET request successful with status code: {response.status_code}")
         return response
 
-    def _post(
-        self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None
-    ) -> httpx.Response:
+    def _post(self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None) -> httpx.Response:
         """
         Make a POST request to the specified URL.
 
@@ -198,9 +184,7 @@ class APIApplication(BaseApplication):
         Raises:
             httpx.HTTPError: If the request fails
         """
-        logger.debug(
-            f"Making POST request to {url} with params: {params} and data: {data}"
-        )
+        logger.debug(f"Making POST request to {url} with params: {params} and data: {data}")
         response = httpx.post(
             url,
             headers=self._get_headers(),
@@ -208,14 +192,10 @@ class APIApplication(BaseApplication):
             params=params,
         )
         response.raise_for_status()
-        logger.debug(
-            f"POST request successful with status code: {response.status_code}"
-        )
+        logger.debug(f"POST request successful with status code: {response.status_code}")
         return response
 
-    def _put(
-        self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None
-    ) -> httpx.Response:
+    def _put(self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None) -> httpx.Response:
         """
         Make a PUT request to the specified URL.
 
@@ -230,9 +210,7 @@ class APIApplication(BaseApplication):
         Raises:
             httpx.HTTPError: If the request fails
         """
-        logger.debug(
-            f"Making PUT request to {url} with params: {params} and data: {data}"
-        )
+        logger.debug(f"Making PUT request to {url} with params: {params} and data: {data}")
         response = self.client.put(
             url,
             json=data,
@@ -259,14 +237,10 @@ class APIApplication(BaseApplication):
         logger.debug(f"Making DELETE request to {url} with params: {params}")
         response = self.client.delete(url, params=params, timeout=self.default_timeout)
         response.raise_for_status()
-        logger.debug(
-            f"DELETE request successful with status code: {response.status_code}"
-        )
+        logger.debug(f"DELETE request successful with status code: {response.status_code}")
         return response
 
-    def _patch(
-        self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None
-    ) -> httpx.Response:
+    def _patch(self, url: str, data: dict[str, Any], params: dict[str, Any] | None = None) -> httpx.Response:
         """
         Make a PATCH request to the specified URL.
 
@@ -281,18 +255,14 @@ class APIApplication(BaseApplication):
         Raises:
             httpx.HTTPError: If the request fails
         """
-        logger.debug(
-            f"Making PATCH request to {url} with params: {params} and data: {data}"
-        )
+        logger.debug(f"Making PATCH request to {url} with params: {params} and data: {data}")
         response = self.client.patch(
             url,
             json=data,
             params=params,
         )
         response.raise_for_status()
-        logger.debug(
-            f"PATCH request successful with status code: {response.status_code}"
-        )
+        logger.debug(f"PATCH request successful with status code: {response.status_code}")
         return response
 
 
@@ -357,11 +327,7 @@ class GraphQLApplication(BaseApplication):
             return headers
 
         # Check if api key is provided
-        api_key = (
-            credentials.get("api_key")
-            or credentials.get("API_KEY")
-            or credentials.get("apiKey")
-        )
+        api_key = credentials.get("api_key") or credentials.get("API_KEY") or credentials.get("apiKey")
         if api_key:
             logger.debug("Using API key from credentials")
             return {
@@ -392,9 +358,7 @@ class GraphQLApplication(BaseApplication):
         if not self._client:
             headers = self._get_headers()
             transport = RequestsHTTPTransport(url=self.base_url, headers=headers)
-            self._client = GraphQLClient(
-                transport=transport, fetch_schema_from_transport=True
-            )
+            self._client = GraphQLClient(transport=transport, fetch_schema_from_transport=True)
         return self._client
 
     def mutate(

universal_mcp/cli.py

@@ -7,8 +7,7 @@ from rich.panel import Panel
 
 from universal_mcp.utils.installation import (
     get_supported_apps,
-    install_claude,
-    install_cursor,
+    install_app,
 )
 
 # Setup rich console and logging
@@ -101,9 +100,7 @@ def docgen(
 
 @app.command()
 def run(
-    config_path: Path | None = typer.Option(
-        None, "--config", "-c", help="Path to the config file"
-    ),
+    config_path: Path | None = typer.Option(None, "--config", "-c", help="Path to the config file"),
 ):
     """Run the MCP server"""
     from universal_mcp.config import ServerConfig
@@ -112,10 +109,7 @@ def run(
 
     setup_logger()
 
-    if config_path:
-        config = ServerConfig.model_validate_json(config_path.read_text())
-    else:
-        config = ServerConfig()
+    config = ServerConfig.model_validate_json(config_path.read_text()) if config_path else ServerConfig()
     server = server_from_config(config)
     server.run(transport=config.transport)
 
@@ -151,14 +145,7 @@ def install(app_name: str = typer.Argument(..., help="Name of app to install")):
         type=str,
     )
     try:
-        if app_name == "claude":
-            console.print(f"[blue]Installing mcp server for: {app_name}[/blue]")
-            install_claude(api_key)
-            console.print("[green]App installed successfully[/green]")
-        elif app_name == "cursor":
-            console.print(f"[blue]Installing mcp server for: {app_name}[/blue]")
-            install_cursor(api_key)
-            console.print("[green]App installed successfully[/green]")
+        install_app(app_name, api_key)
     except Exception as e:
         console.print(f"[red]Error installing app: {e}[/red]")
         raise typer.Exit(1) from e
@@ -219,18 +206,12 @@ def init(
     if not output_dir.exists():
         try:
             output_dir.mkdir(parents=True, exist_ok=True)
-            console.print(
-                f"[green]✅ Created output directory at '{output_dir}'[/green]"
-            )
+            console.print(f"[green]✅ Created output directory at '{output_dir}'[/green]")
         except Exception as e:
-            console.print(
-                f"[red]❌ Failed to create output directory '{output_dir}': {e}[/red]"
-            )
+            console.print(f"[red]❌ Failed to create output directory '{output_dir}': {e}[/red]")
             raise typer.Exit(code=1) from e
     elif not output_dir.is_dir():
-        console.print(
-            f"[red]❌ Output path '{output_dir}' exists but is not a directory.[/red]"
-        )
+        console.print(f"[red]❌ Output path '{output_dir}' exists but is not a directory.[/red]")
         raise typer.Exit(code=1)
 
     # Integration type
@@ -241,9 +222,7 @@ def init(
             prompt_suffix=" (api_key, oauth, agentr, none): ",
         ).lower()
     if integration_type not in ("api_key", "oauth", "agentr", "none"):
-        console.print(
-            "[red]❌ Integration type must be one of: api_key, oauth, agentr, none[/red]"
-        )
+        console.print("[red]❌ Integration type must be one of: api_key, oauth, agentr, none[/red]")
         raise typer.Exit(code=1)
 
     console.print("[blue]🚀 Generating project using cookiecutter...[/blue]")
@@ -264,12 +243,14 @@ def init(
     project_dir = output_dir / f"{app_name}"
     console.print(f"✅ Project created at {project_dir}")
 
+
 @app.command()
 def preprocess(
     schema_path: Path = typer.Option(None, "--schema", "-s", help="Path to the OpenAPI schema file."),
     output_path: Path = typer.Option(None, "--output", "-o", help="Path to save the processed schema."),
 ):
     from universal_mcp.utils.openapi.preprocessor import run_preprocessing
+
     """Preprocess an OpenAPI schema using LLM to fill or enhance descriptions."""
     run_preprocessing(schema_path, output_path)
 

universal_mcp/config.py

@@ -12,9 +12,7 @@ class StoreConfig(BaseModel):
     type: Literal["memory", "environment", "keyring", "agentr"] = Field(
         default="memory", description="Type of credential storage to use"
     )
-    path: Path | None = Field(
-        default=None, description="Path to store credentials (if applicable)"
-    )
+    path: Path | None = Field(default=None, description="Path to store credentials (if applicable)")
 
 
 class IntegrationConfig(BaseModel):
@@ -24,24 +22,16 @@ class IntegrationConfig(BaseModel):
     type: Literal["api_key", "oauth", "agentr", "oauth2"] = Field(
         default="api_key", description="Type of authentication to use"
     )
-    credentials: dict[str, Any] | None = Field(
-        default=None, description="Integration-specific credentials"
-    )
-    store: StoreConfig | None = Field(
-        default=None, description="Store configuration for credentials"
-    )
+    credentials: dict[str, Any] | None = Field(default=None, description="Integration-specific credentials")
+    store: StoreConfig | None = Field(default=None, description="Store configuration for credentials")
 
 
 class AppConfig(BaseModel):
     """Configuration for individual applications."""
 
     name: str = Field(..., description="Name of the application")
-    integration: IntegrationConfig | None = Field(
-        default=None, description="Integration configuration"
-    )
-    actions: list[str] | None = Field(
-        default=None, description="List of available actions"
-    )
+    integration: IntegrationConfig | None = Field(default=None, description="Integration configuration")
+    actions: list[str] | None = Field(default=None, description="List of available actions")
 
 
 class ServerConfig(BaseSettings):
@@ -56,46 +46,24 @@ class ServerConfig(BaseSettings):
     )
 
     name: str = Field(default="Universal MCP", description="Name of the MCP server")
-    description: str = Field(
-        default="Universal MCP", description="Description of the MCP server"
-    )
-    api_key: SecretStr | None = Field(
-        default=None, description="API key for authentication"
-    )
-    type: Literal["local", "agentr"] = Field(
-        default="agentr", description="Type of server deployment"
-    )
-    transport: Literal["stdio", "sse", "http"] = Field(
-        default="stdio", description="Transport protocol to use"
-    )
-    port: int = Field(
-        default=8005, description="Port to run the server on (if applicable)"
-    )
-    host: str = Field(
-        default="localhost", description="Host to bind the server to (if applicable)"
-    )
-    apps: list[AppConfig] | None = Field(
-        default=None, description="List of configured applications"
-    )
-    store: StoreConfig | None = Field(
-        default=None, description="Default store configuration"
-    )
+    description: str = Field(default="Universal MCP", description="Description of the MCP server")
+    api_key: SecretStr | None = Field(default=None, description="API key for authentication")
+    type: Literal["local", "agentr"] = Field(default="agentr", description="Type of server deployment")
+    transport: Literal["stdio", "sse", "http"] = Field(default="stdio", description="Transport protocol to use")
+    port: int = Field(default=8005, description="Port to run the server on (if applicable)")
+    host: str = Field(default="localhost", description="Host to bind the server to (if applicable)")
+    apps: list[AppConfig] | None = Field(default=None, description="List of configured applications")
+    store: StoreConfig | None = Field(default=None, description="Default store configuration")
     debug: bool = Field(default=False, description="Enable debug mode")
     log_level: str = Field(default="INFO", description="Logging level")
-    max_connections: int = Field(
-        default=100, description="Maximum number of concurrent connections"
-    )
-    request_timeout: int = Field(
-        default=60, description="Default request timeout in seconds"
-    )
+    max_connections: int = Field(default=100, description="Maximum number of concurrent connections")
+    request_timeout: int = Field(default=60, description="Default request timeout in seconds")
 
     @field_validator("log_level", mode="before")
     def validate_log_level(cls, v: str) -> str:
         valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
         if v.upper() not in valid_levels:
-            raise ValueError(
-                f"Invalid log level. Must be one of: {', '.join(valid_levels)}"
-            )
+            raise ValueError(f"Invalid log level. Must be one of: {', '.join(valid_levels)}")
         return v.upper()
 
     @field_validator("port", mode="before")

universal_mcp/integrations/__init__.py

@@ -8,9 +8,7 @@ from universal_mcp.integrations.integration import (
 from universal_mcp.stores.store import BaseStore
 
 
-def integration_from_config(
-    config: IntegrationConfig, store: BaseStore | None = None, **kwargs
-) -> Integration:
+def integration_from_config(config: IntegrationConfig, store: BaseStore | None = None, **kwargs) -> Integration:
     if config.type == "api_key":
         return ApiKeyIntegration(config.name, store=store, **kwargs)
     elif config.type == "agentr":

universal_mcp/logger.py

@@ -5,6 +5,21 @@ from pathlib import Path
 from loguru import logger
 
 
+def get_log_file_path(app_name: str = "universal-mcp") -> Path:
+    """Get a standardized log file path for an application.
+
+    Args:
+        app_name: Name of the application.
+
+    Returns:
+        Path to the log file in the format: logs/{app_name}/{app_name}_{date}.log
+    """
+    date_str = datetime.now().strftime("%Y%m%d")
+    home = Path.home()
+    log_dir = home / ".universal-mcp" / "logs"
+    return log_dir / f"{app_name}_{date_str}.log"
+
+
 def setup_logger(
     log_file: Path | None = None,
     rotation: str = "10 MB",
@@ -35,34 +50,21 @@ def setup_logger(
         backtrace=True,
         diagnose=True,
     )
+    if not log_file:
+        log_file = get_log_file_path()
 
-    # Add file handler if log_file is specified
-    if log_file:
-        # Ensure log directory exists
-        log_file.parent.mkdir(parents=True, exist_ok=True)
-
-        logger.add(
-            sink=str(log_file),
-            rotation=rotation,
-            retention=retention,
-            compression=compression,
-            level=level,
-            format=format,
-            enqueue=True,
-            backtrace=True,
-            diagnose=True,
-        )
-
-
-def get_log_file_path(app_name: str) -> Path:
-    """Get a standardized log file path for an application.
+    # Ensure log directory exists
+    log_file.parent.mkdir(parents=True, exist_ok=True)
 
-    Args:
-        app_name: Name of the application.
-
-    Returns:
-        Path to the log file in the format: logs/{app_name}/{app_name}_{date}.log
-    """
-    date_str = datetime.now().strftime("%Y%m%d")
-    log_dir = Path("logs") / app_name
-    return log_dir / f"{app_name}_{date_str}.log"
+    logger.add(
+        sink=str(log_file),
+        rotation=rotation,
+        retention=retention,
+        compression=compression,
+        level=level,
+        format=format,
+        enqueue=True,
+        backtrace=True,
+        diagnose=True,
+    )
+    logger.info(f"Logging to {log_file}")

universal_mcp/servers/server.py

@@ -28,9 +28,7 @@ class BaseServer(FastMCP, ABC):
 
     def __init__(self, config: ServerConfig, **kwargs):
         super().__init__(config.name, config.description, port=config.port, **kwargs)
-        logger.info(
-            f"Initializing server: {config.name} ({config.type}) with store: {config.store}"
-        )
+        logger.info(f"Initializing server: {config.name} ({config.type}) with store: {config.store}")
 
         self.config = config  # Store config at base level for consistency
         self._tool_manager = ToolManager(warn_on_duplicate_tools=True)
@@ -67,19 +65,13 @@ class BaseServer(FastMCP, ABC):
         """
         if isinstance(result, str):
             return [TextContent(type="text", text=result)]
-        elif isinstance(result, list) and all(
-            isinstance(item, TextContent) for item in result
-        ):
+        elif isinstance(result, list) and all(isinstance(item, TextContent) for item in result):
             return result
         else:
-            logger.warning(
-                f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent."
-            )
+            logger.warning(f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent.")
             return [TextContent(type="text", text=str(result))]
 
-    async def call_tool(
-        self, name: str, arguments: dict[str, Any]
-    ) -> list[TextContent]:
+    async def call_tool(self, name: str, arguments: dict[str, Any]) -> list[TextContent]:
         """Call a tool with comprehensive error handling.
 
         Args:
@@ -139,9 +131,7 @@ class LocalServer(BaseServer):
         """
         try:
             integration = (
-                integration_from_config(app_config.integration, store=self.store)
-                if app_config.integration
-                else None
+                integration_from_config(app_config.integration, store=self.store) if app_config.integration else None
             )
             return app_from_slug(app_config.name)(integration=integration)
         except Exception as e:
@@ -200,9 +190,7 @@ class AgentRServer(BaseServer):
         """
         try:
             integration = (
-                AgentRIntegration(
-                    name=app_config.integration.name, api_key=self.client.api_key
-                )
+                AgentRIntegration(name=app_config.integration.name, api_key=self.client.api_key)
                 if app_config.integration
                 else None
             )

universal_mcp/tools/func_metadata.py

@@ -15,9 +15,7 @@ from pydantic_core import PydanticUndefined
 
 
 def _get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:
-    def try_eval_type(
-        value: Any, globalns: dict[str, Any], localns: dict[str, Any]
-    ) -> tuple[Any, bool]:
+    def try_eval_type(value: Any, globalns: dict[str, Any], localns: dict[str, Any]) -> tuple[Any, bool]:
         try:
             return eval_type_backport(value, globalns, localns), True
         except NameError:
@@ -169,9 +167,7 @@ class FuncMetadata(BaseModel):
         globalns = getattr(func, "__globals__", {})
         for param in params.values():
             if param.name.startswith("_"):
-                raise InvalidSignature(
-                    f"Parameter {param.name} of {func.__name__} cannot start with '_'"
-                )
+                raise InvalidSignature(f"Parameter {param.name} of {func.__name__} cannot start with '_'")
             if param.name in skip_names:
                 continue
             annotation = param.annotation
@@ -180,11 +176,7 @@ class FuncMetadata(BaseModel):
             if annotation is None:
                 annotation = Annotated[
                     None,
-                    Field(
-                        default=param.default
-                        if param.default is not inspect.Parameter.empty
-                        else PydanticUndefined
-                    ),
+                    Field(default=param.default if param.default is not inspect.Parameter.empty else PydanticUndefined),
                 ]
 
             # Untyped field
@@ -198,15 +190,9 @@ class FuncMetadata(BaseModel):
 
             field_info = FieldInfo.from_annotated_attribute(
                 _get_typed_annotation(annotation, globalns),
-                param.default
-                if param.default is not inspect.Parameter.empty
-                else PydanticUndefined,
+                param.default if param.default is not inspect.Parameter.empty else PydanticUndefined,
             )
-            if (
-                not field_info.title
-                and arg_description
-                and arg_description.get(param.name)
-            ):
+            if not field_info.title and arg_description and arg_description.get(param.name):
                 field_info.title = arg_description.get(param.name)
             dynamic_pydantic_model_params[param.name] = (
                 field_info.annotation,