fix: correct Windows CLI detection for npm-installed tools (#294)

* fix: correct Windows CLI detection for npm-installed tools

The CLI managers for Claude Code, Gemini CLI, Codex CLI, and Qwen CLI
were incorrectly searching for `.exe` files on Windows. These tools are
installed via npm which creates `.cmd` wrapper scripts, not `.exe` files.

The fix removes the explicit `.exe` extension check because `shutil.which()`
automatically handles Windows PATHEXT environment variable, which includes
`.CMD`, `.BAT`, `.EXE`, and other executable extensions.

Before: `shutil.which("claude.exe")` -> None (not found)
After:  `shutil.which("claude")` -> finds claude.cmd via PATHEXT

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: use Path objects for cross-platform path handling

- Add get_config_directory() and get_data_directory() to platform.py
- Update config.py, global_config.py, profile_config.py to use Path
- Update install.py and tunnel.py to use Path for consistent separators
- Fix test_profile.py to work with Path objects

This fixes mixed path separators on Windows (e.g., C:\Users\btf/.config/mcpm)
by using pathlib.Path throughout the codebase.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: address PR review comments

- Remove unused CERTIFICATE_PATH and DEFAULT_CONFIG_DIR import in tunnel.py
- Fix initialization order in GlobalConfigManager (ensure_dirs before loading)
- Move Path import to top-level in config.py
- Add documentation for architectural decisions in platform.py
- Clean up test imports in test_profile.py and test_qwen_cli.py
- Remove unnecessary mock in test_qwen_cli_manager_is_client_installed_windows

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: address Gemini and CodeRabbit review comments

- Add type hints to ConfigManager constructor (config.py)
- Add error handling for config save operations (config.py, global_config.py)
- Fix type hint: `any` -> `Any` in global_config.py
- Refactor CLI detection to reduce duplication (doctor.py)
- Update qwen_cli.py to use shutil.which for cross-platform detection
- Fix test imports in test_qwen_cli.py

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Kirill Turanskiy <kt@novamedia.ru>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: 3 people

src/mcpm/clients/managers/claude_code.py

@@ -42,8 +42,8 @@ def is_client_installed(self) -> bool:
         Returns:
             bool: True if claude command is available, False otherwise
         """
-        claude_executable = "claude.exe" if self._system == "Windows" else "claude"
-        return shutil.which(claude_executable) is not None
+        # shutil.which() handles Windows PATHEXT automatically (.cmd, .bat, .exe, etc.)
+        return shutil.which("claude") is not None
 
     def get_client_info(self) -> Dict[str, str]:
         """Get information about this client

src/mcpm/clients/managers/codex_cli.py

@@ -47,8 +47,8 @@ def is_client_installed(self) -> bool:
         Returns:
             bool: True if codex command is available, False otherwise
         """
-        codex_executable = "codex.exe" if self._system == "Windows" else "codex"
-        return shutil.which(codex_executable) is not None
+        # shutil.which() handles Windows PATHEXT automatically (.cmd, .bat, .exe, etc.)
+        return shutil.which("codex") is not None
 
     def get_client_info(self) -> Dict[str, str]:
         """Get information about this client

src/mcpm/clients/managers/gemini_cli.py

@@ -49,8 +49,8 @@ def is_client_installed(self) -> bool:
         Returns:
             bool: True if gemini command is available, False otherwise
         """
-        gemini_executable = "gemini.exe" if self._system == "Windows" else "gemini"
-        return shutil.which(gemini_executable) is not None
+        # shutil.which() handles Windows PATHEXT automatically (.cmd, .bat, .exe, etc.)
+        return shutil.which("gemini") is not None
 
     def get_client_info(self) -> Dict[str, str]:
         """Get information about this client

src/mcpm/clients/managers/qwen_cli.py

@@ -3,8 +3,8 @@
 """
 
 import logging
-import os
 import shutil
+from pathlib import Path
 from typing import Any, Dict
 
 from mcpm.clients.base import JSONClientManager
@@ -27,7 +27,7 @@ def __init__(self, config_path_override: str | None = None):
             config_path_override: Optional path to override the default config file location
         """
         # Qwen CLI stores its settings in ~/.qwen/settings.json
-        self.config_path = os.path.expanduser("~/.qwen/settings.json")
+        self.config_path = str(Path.home() / ".qwen" / "settings.json")
         super().__init__(config_path_override=config_path_override)
 
     def _get_empty_config(self) -> Dict[str, Any]:
@@ -44,8 +44,8 @@ def is_client_installed(self) -> bool:
         Returns:
             bool: True if qwen command is available, False otherwise
         """
-        qwen_executable = "qwen.exe" if self._system == "Windows" else "qwen"
-        return shutil.which(qwen_executable) is not None
+        # shutil.which() handles Windows PATHEXT automatically (.cmd, .bat, .exe, etc.)
+        return shutil.which("qwen") is not None
 
     def get_client_info(self) -> Dict[str, str]:
         """Get information about this client

src/mcpm/commands/doctor.py

@@ -1,6 +1,7 @@
 """Doctor command for MCPM - System health check and diagnostics"""
 
 import os
+import shutil
 import subprocess
 import sys
 from pathlib import Path
@@ -48,21 +49,27 @@ def doctor():
     console.print(f"  ✅ Python version: {sys.version.split()[0]}")
     console.print(f"  ✅ Python executable: {sys.executable}")
 
+    # Helper function to check CLI tools
+    def _check_cli_tool(tool_name: str, display_name: str, not_found_msg: str) -> int:
+        """Checks for a CLI tool, prints status, and returns 1 if an issue is found."""
+        tool_path = shutil.which(tool_name)
+        if tool_path:
+            try:
+                version = subprocess.check_output([tool_path, "--version"], stderr=subprocess.DEVNULL).decode().strip()
+                console.print(f"  ✅ {display_name} version: {version}")
+                return 0
+            except (subprocess.CalledProcessError, OSError):
+                console.print(f"  ⚠️  {display_name} found but failed to get version")
+                return 1
+        else:
+            console.print(f"  ⚠️  {not_found_msg}")
+            return 1
+
     # 3. Check Node.js (for npx servers)
+    # Use shutil.which() to find executables - handles Windows .cmd/.bat files via PATHEXT
     console.print("[bold cyan]📊 Node.js Environment[/]")
-    try:
-        node_version = subprocess.check_output(["node", "--version"], stderr=subprocess.DEVNULL).decode().strip()
-        console.print(f"  ✅ Node.js version: {node_version}")
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        console.print("  ⚠️  Node.js not found - npx servers will not work")
-        issues_found += 1
-
-    try:
-        npm_version = subprocess.check_output(["npm", "--version"], stderr=subprocess.DEVNULL).decode().strip()
-        console.print(f"  ✅ npm version: {npm_version}")
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        console.print("  ⚠️  npm not found - package installation may fail")
-        issues_found += 1
+    issues_found += _check_cli_tool("node", "Node.js", "Node.js not found - npx servers will not work")
+    issues_found += _check_cli_tool("npm", "npm", "npm not found - package installation may fail")
 
     # 4. Check MCPM configuration
     console.print("[bold cyan]⚙️  MCPM Configuration[/]")

src/mcpm/commands/install.py

@@ -21,6 +21,7 @@
 from mcpm.schemas.full_server_config import FullServerConfig
 from mcpm.utils.config import NODE_EXECUTABLES, ConfigManager
 from mcpm.utils.non_interactive import is_explicit_non_interactive, should_force_operation
+from mcpm.utils.platform import get_data_directory
 from mcpm.utils.repository import RepositoryManager
 from mcpm.utils.rich_click_config import click
 
@@ -55,6 +56,7 @@ def _get_prompt_session() -> Optional[PromptSession]:
 
     return prompt_session
 
+
 style = Style.from_dict(
     {
         "prompt": "ansicyan bold",
@@ -223,14 +225,14 @@ def install(server_name, force=False, alias=None):
         return
 
     # Create server directory in the MCP directory
-    base_dir = os.path.expanduser("~/.mcpm")
-    os.makedirs(base_dir, exist_ok=True)
+    base_dir = get_data_directory()
+    base_dir.mkdir(parents=True, exist_ok=True)
 
-    servers_dir = os.path.join(base_dir, "servers")
-    os.makedirs(servers_dir, exist_ok=True)
+    servers_dir = base_dir / "servers"
+    servers_dir.mkdir(parents=True, exist_ok=True)
 
-    server_dir = os.path.join(servers_dir, server_name)
-    os.makedirs(server_dir, exist_ok=True)
+    server_dir = servers_dir / server_name
+    server_dir.mkdir(parents=True, exist_ok=True)
 
     # Extract installation information
     installations = server_metadata.get("installations", {})
@@ -304,7 +306,7 @@ def install(server_name, force=False, alias=None):
     with Progress(SpinnerColumn(), TextColumn("[bold green]{task.description}[/]"), console=console) as progress:
         # Save metadata to server directory
         progress.add_task("Saving server metadata...", total=None)
-        metadata_path = os.path.join(server_dir, "metadata.json")
+        metadata_path = server_dir / "metadata.json"
         with open(metadata_path, "w", encoding="utf-8") as f:
             json.dump(server_metadata, f, indent=2)
 

src/mcpm/core/tunnel.py

@@ -10,7 +10,6 @@
 
 import httpx
 
-from mcpm.utils.config import DEFAULT_CONFIG_DIR
 from mcpm.utils.platform import get_frpc_directory
 
 VERSION = "0.3"
@@ -53,8 +52,6 @@
 TUNNEL_TIMEOUT_SECONDS = 30
 TUNNEL_ERROR_MESSAGE = "Could not create share URL. Please check the appended log from frpc for more information:"
 
-CERTIFICATE_PATH = f"{DEFAULT_CONFIG_DIR}/certificate.pem"
-
 
 class Tunnel:
     def __init__(

src/mcpm/global_config.py

@@ -7,15 +7,16 @@
 
 import json
 import logging
-import os
-from typing import Dict, List, Optional
+from pathlib import Path
+from typing import Any, Dict, List, Optional
 
 from pydantic import TypeAdapter
 
 from mcpm.core.schema import ProfileMetadata, ServerConfig
+from mcpm.utils.platform import get_config_directory
 
-DEFAULT_GLOBAL_CONFIG_PATH = os.path.expanduser("~/.config/mcpm/servers.json")
-DEFAULT_PROFILE_METADATA_PATH = os.path.expanduser("~/.config/mcpm/profiles_metadata.json")
+DEFAULT_GLOBAL_CONFIG_PATH = get_config_directory() / "servers.json"
+DEFAULT_PROFILE_METADATA_PATH = get_config_directory() / "profiles_metadata.json"
 
 logger = logging.getLogger(__name__)
 
@@ -28,22 +29,22 @@ class GlobalConfigManager:
     """
 
     def __init__(
-        self, config_path: str = DEFAULT_GLOBAL_CONFIG_PATH, metadata_path: str = DEFAULT_PROFILE_METADATA_PATH
+        self, config_path: Path = DEFAULT_GLOBAL_CONFIG_PATH, metadata_path: Path = DEFAULT_PROFILE_METADATA_PATH
     ):
-        self.config_path = os.path.expanduser(config_path)
-        self.metadata_path = os.path.expanduser(metadata_path)
-        self.config_dir = os.path.dirname(self.config_path)
+        self.config_path = Path(config_path)
+        self.metadata_path = Path(metadata_path)
+        self.config_dir = self.config_path.parent
+        self._ensure_dirs()
         self._servers: Dict[str, ServerConfig] = self._load_servers()
         self._profile_metadata: Dict[str, ProfileMetadata] = self._load_profile_metadata()
-        self._ensure_dirs()
 
     def _ensure_dirs(self) -> None:
         """Ensure all configuration directories exist"""
-        os.makedirs(self.config_dir, exist_ok=True)
+        self.config_dir.mkdir(parents=True, exist_ok=True)
 
     def _load_servers(self) -> Dict[str, ServerConfig]:
         """Load servers from the global configuration file."""
-        if not os.path.exists(self.config_path):
+        if not self.config_path.exists():
             return {}
 
         try:
@@ -68,12 +69,15 @@ def _save_servers(self) -> None:
         self._ensure_dirs()
         servers_data = {name: config.model_dump() for name, config in self._servers.items()}
 
-        with open(self.config_path, "w", encoding="utf-8") as f:
-            json.dump(servers_data, f, indent=2)
+        try:
+            with open(self.config_path, "w", encoding="utf-8") as f:
+                json.dump(servers_data, f, indent=2)
+        except OSError as e:
+            logger.error(f"Error saving servers to {self.config_path}: {e}")
 
     def _load_profile_metadata(self) -> Dict[str, ProfileMetadata]:
         """Load profile metadata from the metadata configuration file."""
-        if not os.path.exists(self.metadata_path):
+        if not self.metadata_path.exists():
             return {}
 
         try:
@@ -98,8 +102,11 @@ def _save_profile_metadata(self) -> None:
         self._ensure_dirs()
         metadata_data = {name: meta.model_dump() for name, meta in self._profile_metadata.items()}
 
-        with open(self.metadata_path, "w", encoding="utf-8") as f:
-            json.dump(metadata_data, f, indent=2)
+        try:
+            with open(self.metadata_path, "w", encoding="utf-8") as f:
+                json.dump(metadata_data, f, indent=2)
+        except OSError as e:
+            logger.error(f"Error saving profile metadata to {self.metadata_path}: {e}")
 
     def add_server(self, server_config: ServerConfig, force: bool = False) -> bool:
         """Add a server to the global configuration.
@@ -358,7 +365,7 @@ def list_profile_metadata(self) -> Dict[str, ProfileMetadata]:
         """
         return self._profile_metadata.copy()
 
-    def get_complete_profile(self, name: str) -> Optional[Dict[str, any]]:
+    def get_complete_profile(self, name: str) -> Optional[Dict[str, Any]]:
         """Get complete profile information including metadata and servers.
 
         Args:

src/mcpm/profile/profile_config.py

@@ -1,11 +1,12 @@
 import logging
-import os
+from pathlib import Path
 from typing import Dict, List, Optional
 
 from mcpm.core.schema import ProfileMetadata, ServerConfig
 from mcpm.global_config import GlobalConfigManager
+from mcpm.utils.platform import get_config_directory
 
-DEFAULT_PROFILE_PATH = os.path.expanduser("~/.config/mcpm/profiles.json")
+DEFAULT_PROFILE_PATH = get_config_directory() / "profiles.json"
 
 logger = logging.getLogger(__name__)
 
@@ -22,9 +23,9 @@ class ProfileConfigManager:
     """
 
     def __init__(
-        self, profile_path: str = DEFAULT_PROFILE_PATH, global_config_manager: Optional[GlobalConfigManager] = None
+        self, profile_path: Path = DEFAULT_PROFILE_PATH, global_config_manager: Optional[GlobalConfigManager] = None
     ):
-        self.profile_path = os.path.expanduser(profile_path)
+        self.profile_path = Path(profile_path)
         self.global_config = global_config_manager or GlobalConfigManager()
 
         # Note: Legacy profile migration is now handled by V1ToV2Migrator

src/mcpm/utils/config.py

@@ -4,15 +4,17 @@
 
 import json
 import logging
-import os
+from pathlib import Path
 from typing import Any, Dict
 
+from mcpm.utils.platform import get_config_directory
+
 logger = logging.getLogger(__name__)
 
-# Default configuration paths
-DEFAULT_CONFIG_DIR = os.path.expanduser("~/.config/mcpm")
-DEFAULT_CONFIG_FILE = os.path.join(DEFAULT_CONFIG_DIR, "config.json")
-DEFAULT_AUTH_FILE = os.path.join(DEFAULT_CONFIG_DIR, "auth.json")
+# Default configuration paths using platform-specific directories
+DEFAULT_CONFIG_DIR = get_config_directory()
+DEFAULT_CONFIG_FILE = DEFAULT_CONFIG_DIR / "config.json"
+DEFAULT_AUTH_FILE = DEFAULT_CONFIG_DIR / "auth.json"
 # Default port for HTTP mode
 DEFAULT_PORT = 6276  # 6276 represents MCPM on a T9 keypad (6=M, 2=C, 7=P, 6=M)
 # Default share address
@@ -28,10 +30,11 @@ class ConfigManager:
     Client-specific configurations are managed by ClientConfigManager.
     """
 
-    def __init__(self, config_path: str = DEFAULT_CONFIG_FILE, auth_path: str = DEFAULT_AUTH_FILE):
-        self.config_path = config_path
-        self.auth_path = auth_path
-        self.config_dir = os.path.dirname(config_path)
+    def __init__(self, config_path: Path | str = DEFAULT_CONFIG_FILE, auth_path: Path | str = DEFAULT_AUTH_FILE):
+        # Normalize paths to Path objects for consistent handling
+        self.config_path = Path(config_path)
+        self.auth_path = Path(auth_path)
+        self.config_dir = self.config_path.parent
         self._config = {}
         self._auth_config = {}
         self._ensure_dirs()
@@ -40,11 +43,11 @@ def __init__(self, config_path: str = DEFAULT_CONFIG_FILE, auth_path: str = DEFA
 
     def _ensure_dirs(self) -> None:
         """Ensure all configuration directories exist"""
-        os.makedirs(self.config_dir, exist_ok=True)
+        self.config_dir.mkdir(parents=True, exist_ok=True)
 
     def _load_config(self) -> None:
         """Load configuration from file or create default"""
-        if os.path.exists(self.config_path):
+        if self.config_path.exists():
             try:
                 with open(self.config_path, "r", encoding="utf-8") as f:
                     self._config = json.load(f)
@@ -57,7 +60,7 @@ def _load_config(self) -> None:
 
     def _load_auth_config(self) -> None:
         """Load auth configuration from file or create default"""
-        if os.path.exists(self.auth_path):
+        if self.auth_path.exists():
             try:
                 with open(self.auth_path, "r", encoding="utf-8") as f:
                     self._auth_config = json.load(f)
@@ -75,13 +78,19 @@ def _default_config(self) -> Dict[str, Any]:
 
     def _save_config(self) -> None:
         """Save current configuration to file"""
-        with open(self.config_path, "w", encoding="utf-8") as f:
-            json.dump(self._config, f, indent=2)
+        try:
+            with open(self.config_path, "w", encoding="utf-8") as f:
+                json.dump(self._config, f, indent=2)
+        except OSError as e:
+            logger.error(f"Error saving config file: {self.config_path} - {e}")
 
     def _save_auth_config(self) -> None:
         """Save current auth configuration to file"""
-        with open(self.auth_path, "w", encoding="utf-8") as f:
-            json.dump(self._auth_config, f, indent=2)
+        try:
+            with open(self.auth_path, "w", encoding="utf-8") as f:
+                json.dump(self._auth_config, f, indent=2)
+        except OSError as e:
+            logger.error(f"Error saving auth file: {self.auth_path} - {e}")
 
     def get_config(self) -> Dict[str, Any]:
         """Get the complete configuration"""