hatch-xclam 0.7.1__py3-none-any.whl → 0.7.1.dev1__py3-none-any.whl

hatch/mcp_host_config/strategies.py

@@ -8,10 +8,8 @@ strategies with decorator registration following Hatchling patterns.
 
 import platform
 import json
-import tomllib  # Python 3.11+ built-in
-import tomli_w  # TOML writing
 from pathlib import Path
-from typing import Optional, Dict, Any, TextIO
+from typing import Optional, Dict, Any
 import logging
 
 from .host_management import MCPHostStrategy, register_host_strategy
@@ -609,172 +607,3 @@ class GeminiHostStrategy(MCPHostStrategy):
         except Exception as e:
             logger.error(f"Failed to write Gemini configuration: {e}")
             return False
-
-
-@register_host_strategy(MCPHostType.CODEX)
-class CodexHostStrategy(MCPHostStrategy):
-    """Configuration strategy for Codex IDE with TOML support.
-
-    Codex uses TOML configuration at ~/.codex/config.toml with a unique
-    structure using [mcp_servers.<server-name>] tables.
-    """
-
-    def __init__(self):
-        self.config_format = "toml"
-        self._preserved_features = {}  # Preserve [features] section
-
-    def get_config_path(self) -> Optional[Path]:
-        """Get Codex configuration path."""
-        return Path.home() / ".codex" / "config.toml"
-
-    def get_config_key(self) -> str:
-        """Codex uses 'mcp_servers' key (note: underscore, not camelCase)."""
-        return "mcp_servers"
-
-    def is_host_available(self) -> bool:
-        """Check if Codex is available by checking for config directory."""
-        codex_dir = Path.home() / ".codex"
-        return codex_dir.exists()
-
-    def validate_server_config(self, server_config: MCPServerConfig) -> bool:
-        """Codex validation - supports both STDIO and HTTP servers."""
-        return server_config.command is not None or server_config.url is not None
-
-    def read_configuration(self) -> HostConfiguration:
-        """Read Codex TOML configuration file."""
-        config_path = self.get_config_path()
-        if not config_path or not config_path.exists():
-            return HostConfiguration(servers={})
-
-        try:
-            with open(config_path, 'rb') as f:
-                toml_data = tomllib.load(f)
-
-            # Preserve [features] section for later write
-            self._preserved_features = toml_data.get('features', {})
-
-            # Extract MCP servers from [mcp_servers.*] tables
-            mcp_servers = toml_data.get(self.get_config_key(), {})
-
-            servers = {}
-            for name, server_data in mcp_servers.items():
-                try:
-                    # Flatten nested env section if present
-                    flat_data = self._flatten_toml_server(server_data)
-                    servers[name] = MCPServerConfig(**flat_data)
-                except Exception as e:
-                    logger.warning(f"Invalid server config for {name}: {e}")
-                    continue
-
-            return HostConfiguration(servers=servers)
-
-        except Exception as e:
-            logger.error(f"Failed to read Codex configuration: {e}")
-            return HostConfiguration(servers={})
-
-    def write_configuration(self, config: HostConfiguration, no_backup: bool = False) -> bool:
-        """Write Codex TOML configuration file with backup support."""
-        config_path = self.get_config_path()
-        if not config_path:
-            return False
-
-        try:
-            config_path.parent.mkdir(parents=True, exist_ok=True)
-
-            # Read existing configuration to preserve non-MCP settings
-            existing_data = {}
-            if config_path.exists():
-                try:
-                    with open(config_path, 'rb') as f:
-                        existing_data = tomllib.load(f)
-                except Exception:
-                    pass
-
-            # Preserve [features] section
-            if 'features' in existing_data:
-                self._preserved_features = existing_data['features']
-
-            # Convert servers to TOML structure
-            servers_data = {}
-            for name, server_config in config.servers.items():
-                servers_data[name] = self._to_toml_server(server_config)
-
-            # Build final TOML structure
-            final_data = {}
-
-            # Preserve [features] at top
-            if self._preserved_features:
-                final_data['features'] = self._preserved_features
-
-            # Add MCP servers
-            final_data[self.get_config_key()] = servers_data
-
-            # Preserve other top-level keys
-            for key, value in existing_data.items():
-                if key not in ('features', self.get_config_key()):
-                    final_data[key] = value
-
-            # Use atomic write with TOML serializer
-            backup_manager = MCPHostConfigBackupManager()
-            atomic_ops = AtomicFileOperations()
-
-            def toml_serializer(data: Any, f: TextIO) -> None:
-                # tomli_w.dumps returns a string, write it to the file
-                toml_str = tomli_w.dumps(data)
-                f.write(toml_str)
-
-            atomic_ops.atomic_write_with_serializer(
-                file_path=config_path,
-                data=final_data,
-                serializer=toml_serializer,
-                backup_manager=backup_manager,
-                hostname="codex",
-                skip_backup=no_backup
-            )
-
-            return True
-
-        except Exception as e:
-            logger.error(f"Failed to write Codex configuration: {e}")
-            return False
-
-    def _flatten_toml_server(self, server_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Flatten nested TOML server structure to flat dict.
-
-        TOML structure:
-            [mcp_servers.name]
-            command = "npx"
-            args = ["-y", "package"]
-            [mcp_servers.name.env]
-            VAR = "value"
-
-        Becomes:
-            {"command": "npx", "args": [...], "env": {"VAR": "value"}}
-
-        Also maps Codex-specific 'http_headers' to universal 'headers' field.
-        """
-        # TOML already parses nested tables into nested dicts
-        # So [mcp_servers.name.env] becomes {"env": {...}}
-        data = dict(server_data)
-
-        # Map Codex 'http_headers' to universal 'headers' for MCPServerConfig
-        if 'http_headers' in data:
-            data['headers'] = data.pop('http_headers')
-
-        return data
-
-    def _to_toml_server(self, server_config: MCPServerConfig) -> Dict[str, Any]:
-        """Convert MCPServerConfig to TOML-compatible dict structure.
-
-        Maps universal 'headers' field back to Codex-specific 'http_headers'.
-        """
-        data = server_config.model_dump(exclude_unset=True)
-
-        # Remove 'name' field as it's the table key in TOML
-        data.pop('name', None)
-
-        # Map universal 'headers' to Codex 'http_headers' for TOML
-        if 'headers' in data:
-            data['http_headers'] = data.pop('headers')
-
-        return data

{hatch_xclam-0.7.1.dist-info → hatch_xclam-0.7.1.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hatch-xclam
-Version: 0.7.1
+Version: 0.7.1.dev1
 Summary: Package manager for the Cracking Shells ecosystem
 Author: Cracking Shells Team
 Project-URL: Homepage, https://github.com/CrackingShells/Hatch
@@ -17,7 +17,6 @@ Requires-Dist: packaging>=20.0
 Requires-Dist: docker>=7.1.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: hatch-validator>=0.8.0
-Requires-Dist: tomli-w>=1.0.0
 Provides-Extra: docs
 Requires-Dist: mkdocs>=1.4.0; extra == "docs"
 Requires-Dist: mkdocstrings[python]>=0.20.0; extra == "docs"
@@ -31,7 +30,7 @@ Dynamic: license-file
 
 ## Introduction
 
-Hatch is the package manager for managing Model Context Protocol (MCP) servers with environment isolation, multi-type dependency resolution, and multi-host deployment. Deploy MCP servers to Claude Desktop, VS Code, Cursor, Kiro, Codex, and other platforms with automatic dependency management.
+Hatch is the package manager for managing Model Context Protocol (MCP) servers with environment isolation, multi-type dependency resolution, and multi-host deployment. Deploy MCP servers to Claude Desktop, VS Code, Cursor, Kiro, and other platforms with automatic dependency management.
 
 The canonical documentation is at `docs/index.md` and published at <https://hatch.readthedocs.io/en/latest/>.
 
@@ -39,7 +38,7 @@ The canonical documentation is at `docs/index.md` and published at <https://hatc
 
 - **Environment Isolation** — Create separate, isolated workspaces for different projects without conflicts
 - **Multi-Type Dependency Resolution** — Automatically resolve and install system packages, Python packages, Docker containers, and Hatch packages
-- **Multi-Host Deployment** — Configure MCP servers on multiple host platforms
+- **Multi-Host Deployment** — Deploy MCP servers to Claude Desktop, Claude Code, VS Code, Cursor, Kiro, LM Studio, and Google Gemini CLI
 - **Package Validation** — Ensure packages meet schema requirements before distribution
 - **Development-Focused** — Optimized for rapid development and testing of MCP server ecosystems
 
@@ -52,7 +51,6 @@ Hatch supports deployment to the following MCP host platforms:
 - **VS Code** — Visual Studio Code with the MCP extension for tool integration
 - **Cursor** — AI-first code editor with built-in MCP server support
 - **Kiro** — Kiro IDE with MCP support
-- **Codex** — OpenAI Codex with MCP server configuration support
 - **LM Studio** — Local LLM inference platform with MCP server integration
 - **Google Gemini CLI** — Command-line interface for Google's Gemini model with MCP support
 

{hatch_xclam-0.7.1.dist-info → hatch_xclam-0.7.1.dev1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 hatch/__init__.py,sha256=5JFQZiaZQewEWg8WktQKEdT8IeH0KstndZf27VH7sq4,594
-hatch/cli_hatch.py,sha256=Z7-N0DdWT1xK23EL0Gr5mx2wjqhDFzFROt1nUxPAnZM,112093
+hatch/cli_hatch.py,sha256=mDWKVA8Cg8lpXElkJbj8-7xyzI1AiJk3nlp2kOtpwPk,109150
 hatch/environment_manager.py,sha256=9R9PJYPKQLmWeGXBrOzXxty20la33LgCCYY8o2aMFBQ,60757
 hatch/package_loader.py,sha256=Sa2JIoio1QlMT2tOGwZhC6pFJIs419cYyoodzyaTDl4,11269
 hatch/python_environment_manager.py,sha256=guU3zz4_WG3ptuX_ATGCRIi_fDxNHlaQtMv3kiRSo8k,28894
@@ -15,13 +15,13 @@ hatch/installers/installer_base.py,sha256=mId6Q_DLOQPZriq3wu3BCU-ckouom3EZgbWJQq
 hatch/installers/python_installer.py,sha256=MS9Q8wKjMAy7MEWk7zcAAiFgN0KzOVJFmMzXt1MSH8g,13632
 hatch/installers/registry.py,sha256=ZOEEMJy_kL5LVj5Mf7s1_CIovDnUVag6nB01dEU9Xeg,6831
 hatch/installers/system_installer.py,sha256=bdrmw3I9g2EU2E94-4vtJj01RhmekX9GxylU1RPT3Lk,22869
-hatch/mcp_host_config/__init__.py,sha256=STHzYwcyO6blKSwcMRibcD_4VKHgpEjru-uY1OQM9yA,1781
-hatch/mcp_host_config/backup.py,sha256=X6wnLkPFYv4e5ObrWQSgQ_a_6rcmsFgysQwBZF_osWM,17831
+hatch/mcp_host_config/__init__.py,sha256=YZ9LEbR5E5p6padhPt114wvcsLCz16c2RPduhvvsj9I,1727
+hatch/mcp_host_config/backup.py,sha256=vl2YLL0P0bobGvx5moSAe4wI47vp25d-NpwNO95J3zU,16875
 hatch/mcp_host_config/host_management.py,sha256=sXyGluFQpfXKggxAVvV9riGRis29JnoEM2dTWSIwb24,23905
-hatch/mcp_host_config/models.py,sha256=1Nd3PDyGGbBm4oTgMEQ67j4b_qy23iibv9N4Tm4d9oE,29110
+hatch/mcp_host_config/models.py,sha256=OM5sKtQF-1hylXijNNRctKpHFQbPA88C3DorwyhGv20,25710
 hatch/mcp_host_config/reporting.py,sha256=Q8UKBJRfvJTbb5PM9xwLEOh3OJjf19AKpWKxs-2622k,6889
-hatch/mcp_host_config/strategies.py,sha256=NdA8hcbAi5xGkFRy51csmdEJESg25L8JkwTDVg2AeMw,30302
-hatch_xclam-0.7.1.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+hatch/mcp_host_config/strategies.py,sha256=WyelujfNtP0Y-KP5hS6u5Z9QSbMWcIxSv30nBQ1Ug7o,23998
+hatch_xclam-0.7.1.dev1.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
 tests/__init__.py,sha256=4I3aQWv143Y1QY_nRIBWnY9MIL-aoQOJuVlpoPQz24E,53
 tests/run_environment_tests.py,sha256=bWCr8UsPgU80SM8f_VSi0TCwDI6JNqZpvZ2W9-b2Lqk,7302
 tests/test_cli_version.py,sha256=lU8TBZfzn_8AenFNXYrLMARht91fI5twBN13L-iJebc,4778
@@ -33,9 +33,9 @@ tests/test_hatch_installer.py,sha256=qHCEcKpbe0fHvkzib2rcUJUw1Z-PCRBBJhbjoyOYiVM
 tests/test_installer_base.py,sha256=0xZiPDMf8LeFJs2SmnYhbIgL7mgvG_HKwL1myQovEZI,11818
 tests/test_mcp_atomic_operations.py,sha256=QmwUDRNZUz6b2i50yRAMBntRDaMMYZt6flHFJfVkzNE,10563
 tests/test_mcp_backup_integration.py,sha256=Auw6Bx1EXGwmCA-mRIy31DRLuRWyV33eB7GJiOvIPXQ,12360
-tests/test_mcp_cli_all_host_specific_args.py,sha256=hvXUetFyoZFtHsEjpzZ0GNdEuvci3Hv8P8thVjBPm-A,18748
+tests/test_mcp_cli_all_host_specific_args.py,sha256=xLmWCgvupfYo5Z107rYyuz4VJdgWFAWBAw7eKokSscw,11302
 tests/test_mcp_cli_backup_management.py,sha256=GlUUNu5K1w8S2jTQ6YISp5KeXH5c-H9F0lJX2SG0JWM,14019
-tests/test_mcp_cli_direct_management.py,sha256=7GRwHXezmImCUfpHhVjvSkGfT-OBi1tMMLgExMXjals,22184
+tests/test_mcp_cli_direct_management.py,sha256=NOlRGP7M3CJ6dzR9JNtqIswJaCT8WIOoy2PhKXlGqSM,21906
 tests/test_mcp_cli_discovery_listing.py,sha256=kdrCU6POLyGW9ejowNV-dUVDFVseMd_vibvgIDjZUCM,26595
 tests/test_mcp_cli_host_config_integration.py,sha256=dD6maHP0wHWnFZwxJ5LgSK1GsrYqB4WdicZkotqIANo,32512
 tests/test_mcp_cli_package_management.py,sha256=YFMhyh3dueel1f2R5_VMNr9AewDmVrqGbU1kj5bhdeo,14590
@@ -59,9 +59,6 @@ tests/test_system_installer.py,sha256=bWuyEKakhvi51iM8xHJh62zv83HUTd8QnPlqUUMWx9
 tests/integration/__init__.py,sha256=2mG53dv1VqjxZYHuglneK9VgDMoWCxpfmPByXXd3zVM,125
 tests/integration/test_mcp_kiro_integration.py,sha256=9y2XPacd3Y6zkqUUcCDjzj8Jv2Humby2LZ5CLSeFYCg,5566
 tests/regression/__init__.py,sha256=0pFnFuEaMf7gPFFXMv-b_vNRNyLV-wU2lYspZHFH_Uo,127
-tests/regression/test_mcp_codex_backup_integration.py,sha256=15G8tCPFtukEcZvE5NBI8BvxlD27KwmE3z8-8ZZ3GxM,7107
-tests/regression/test_mcp_codex_host_strategy.py,sha256=6ehG8IruT9U-fO7kDMoJfogXbpq7JV4XYl-Ho68nt1U,6413
-tests/regression/test_mcp_codex_model_validation.py,sha256=LkGexJrDusxRg_5Bpsm7sXRt7LYwhqqj4Y7VIynslyw,4512
 tests/regression/test_mcp_kiro_backup_integration.py,sha256=oBEnSSLrnHIurkrBtjSG-HT6DyODV2z9tZeZotnsR1k,9584
 tests/regression/test_mcp_kiro_cli_integration.py,sha256=jDQE73yJTRb2e6MPShxLHmLDtN5VBMHMAUBojPEnVBI,5123
 tests/regression/test_mcp_kiro_decorator_registration.py,sha256=_H9FdKdKCv__IYBS0tfnZGUP574KoDjqKInmFiDEKPc,2556
@@ -98,8 +95,8 @@ tests/test_data/packages/schema_versions/schema_v1_1_0_pkg/main.py,sha256=_B5aqX
 tests/test_data/packages/schema_versions/schema_v1_2_0_pkg/main.py,sha256=rinhVySJpjXKd2sRCS0ps7xTrVqImWcZ8l4aYbidYR8,238
 tests/test_data/packages/schema_versions/schema_v1_2_1_pkg/hatch_mcp_server.py,sha256=FT14llzHlA4i8I__8GugzBRowhg_CbLmsOwjq0IWFsY,368
 tests/test_data/packages/schema_versions/schema_v1_2_1_pkg/mcp_server.py,sha256=BRPAyyAseE2CGR3W647SwjlluYfi7ejhZck0An5581I,467
-hatch_xclam-0.7.1.dist-info/METADATA,sha256=RfpwtyksekYsi6tz0Jsd36Ssgo789woFnpjyhnam8hA,5942
-hatch_xclam-0.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hatch_xclam-0.7.1.dist-info/entry_points.txt,sha256=6xbkwFUtr7nRa56vUFMyJk2wjwFQ_XVaU53ruecWKI0,47
-hatch_xclam-0.7.1.dist-info/top_level.txt,sha256=GZP3Ivciwal8jVITQkQr7dSNlLJRzfNOhA76VN7Jp4Y,12
-hatch_xclam-0.7.1.dist-info/RECORD,,
+hatch_xclam-0.7.1.dev1.dist-info/METADATA,sha256=SMSh9ptwXOL_vYr8I881UViJS5LbPXXh6B9nXGsmfek,5901
+hatch_xclam-0.7.1.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hatch_xclam-0.7.1.dev1.dist-info/entry_points.txt,sha256=6xbkwFUtr7nRa56vUFMyJk2wjwFQ_XVaU53ruecWKI0,47
+hatch_xclam-0.7.1.dev1.dist-info/top_level.txt,sha256=GZP3Ivciwal8jVITQkQr7dSNlLJRzfNOhA76VN7Jp4Y,12
+hatch_xclam-0.7.1.dev1.dist-info/RECORD,,

tests/test_mcp_cli_all_host_specific_args.py

@@ -15,7 +15,7 @@ from hatch.cli_hatch import handle_mcp_configure, parse_input
 from hatch.mcp_host_config import MCPHostType
 from hatch.mcp_host_config.models import (
     MCPServerConfigGemini, MCPServerConfigCursor, MCPServerConfigVSCode,
-    MCPServerConfigClaude, MCPServerConfigCodex
+    MCPServerConfigClaude
 )
 
 
@@ -298,199 +298,6 @@ class TestToolFilteringArguments(unittest.TestCase):
         self.assertEqual(server_config.excludeTools, ['dangerous_tool'])
 
 
-class TestAllCodexArguments(unittest.TestCase):
-    """Test ALL Codex-specific CLI arguments."""
-
-    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_all_codex_arguments_accepted(self, mock_stdout, mock_manager_class):
-        """Test that all Codex arguments are accepted and passed to model."""
-        mock_manager = MagicMock()
-        mock_manager_class.return_value = mock_manager
-
-        mock_result = MagicMock()
-        mock_result.success = True
-        mock_result.backup_path = None
-        mock_manager.configure_server.return_value = mock_result
-
-        # Test STDIO server with Codex-specific STDIO fields
-        result = handle_mcp_configure(
-            host='codex',
-            server_name='test-server',
-            command='npx',
-            args=['-y', '@upstash/context7-mcp'],
-            env_vars=['PATH', 'HOME'],
-            cwd='/workspace',
-            startup_timeout=15,
-            tool_timeout=120,
-            enabled=True,
-            include_tools=['read', 'write'],
-            exclude_tools=['delete'],
-            auto_approve=True
-        )
-
-        # Verify success
-        self.assertEqual(result, 0)
-
-        # Verify configure_server was called
-        mock_manager.configure_server.assert_called_once()
-
-        # Verify server_config is MCPServerConfigCodex
-        call_args = mock_manager.configure_server.call_args
-        server_config = call_args.kwargs['server_config']
-        self.assertIsInstance(server_config, MCPServerConfigCodex)
-
-        # Verify Codex-specific STDIO fields
-        self.assertEqual(server_config.env_vars, ['PATH', 'HOME'])
-        self.assertEqual(server_config.cwd, '/workspace')
-        self.assertEqual(server_config.startup_timeout_sec, 15)
-        self.assertEqual(server_config.tool_timeout_sec, 120)
-        self.assertTrue(server_config.enabled)
-        self.assertEqual(server_config.enabled_tools, ['read', 'write'])
-        self.assertEqual(server_config.disabled_tools, ['delete'])
-
-    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_codex_env_vars_list(self, mock_stdout, mock_manager_class):
-        """Test that env_vars accepts multiple values as a list."""
-        mock_manager = MagicMock()
-        mock_manager_class.return_value = mock_manager
-
-        mock_result = MagicMock()
-        mock_result.success = True
-        mock_result.backup_path = None
-        mock_manager.configure_server.return_value = mock_result
-
-        result = handle_mcp_configure(
-            host='codex',
-            server_name='test-server',
-            command='npx',
-            args=['-y', 'package'],
-            env_vars=['PATH', 'HOME', 'USER'],
-            auto_approve=True
-        )
-
-        self.assertEqual(result, 0)
-        call_args = mock_manager.configure_server.call_args
-        server_config = call_args.kwargs['server_config']
-        self.assertEqual(server_config.env_vars, ['PATH', 'HOME', 'USER'])
-
-    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_codex_env_header_parsing(self, mock_stdout, mock_manager_class):
-        """Test that env_header parses KEY=ENV_VAR format correctly."""
-        mock_manager = MagicMock()
-        mock_manager_class.return_value = mock_manager
-
-        mock_result = MagicMock()
-        mock_result.success = True
-        mock_result.backup_path = None
-        mock_manager.configure_server.return_value = mock_result
-
-        result = handle_mcp_configure(
-            host='codex',
-            server_name='test-server',
-            command='npx',
-            args=['-y', 'package'],
-            env_header=['X-API-Key=API_KEY', 'Authorization=AUTH_TOKEN'],
-            auto_approve=True
-        )
-
-        self.assertEqual(result, 0)
-        call_args = mock_manager.configure_server.call_args
-        server_config = call_args.kwargs['server_config']
-        self.assertEqual(server_config.env_http_headers, {
-            'X-API-Key': 'API_KEY',
-            'Authorization': 'AUTH_TOKEN'
-        })
-
-    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_codex_timeout_fields(self, mock_stdout, mock_manager_class):
-        """Test that timeout fields are passed as integers."""
-        mock_manager = MagicMock()
-        mock_manager_class.return_value = mock_manager
-
-        mock_result = MagicMock()
-        mock_result.success = True
-        mock_result.backup_path = None
-        mock_manager.configure_server.return_value = mock_result
-
-        result = handle_mcp_configure(
-            host='codex',
-            server_name='test-server',
-            command='npx',
-            args=['-y', 'package'],
-            startup_timeout=30,
-            tool_timeout=180,
-            auto_approve=True
-        )
-
-        self.assertEqual(result, 0)
-        call_args = mock_manager.configure_server.call_args
-        server_config = call_args.kwargs['server_config']
-        self.assertEqual(server_config.startup_timeout_sec, 30)
-        self.assertEqual(server_config.tool_timeout_sec, 180)
-
-    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_codex_enabled_flag(self, mock_stdout, mock_manager_class):
-        """Test that enabled flag works as boolean."""
-        mock_manager = MagicMock()
-        mock_manager_class.return_value = mock_manager
-
-        mock_result = MagicMock()
-        mock_result.success = True
-        mock_result.backup_path = None
-        mock_manager.configure_server.return_value = mock_result
-
-        result = handle_mcp_configure(
-            host='codex',
-            server_name='test-server',
-            command='npx',
-            args=['-y', 'package'],
-            enabled=True,
-            auto_approve=True
-        )
-
-        self.assertEqual(result, 0)
-        call_args = mock_manager.configure_server.call_args
-        server_config = call_args.kwargs['server_config']
-        self.assertTrue(server_config.enabled)
-
-    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_codex_reuses_shared_arguments(self, mock_stdout, mock_manager_class):
-        """Test that Codex reuses shared arguments (cwd, include-tools, exclude-tools)."""
-        mock_manager = MagicMock()
-        mock_manager_class.return_value = mock_manager
-
-        mock_result = MagicMock()
-        mock_result.success = True
-        mock_result.backup_path = None
-        mock_manager.configure_server.return_value = mock_result
-
-        result = handle_mcp_configure(
-            host='codex',
-            server_name='test-server',
-            command='npx',
-            args=['-y', 'package'],
-            cwd='/workspace',
-            include_tools=['tool1', 'tool2'],
-            exclude_tools=['tool3'],
-            auto_approve=True
-        )
-
-        self.assertEqual(result, 0)
-        call_args = mock_manager.configure_server.call_args
-        server_config = call_args.kwargs['server_config']
-
-        # Verify shared arguments work for Codex STDIO servers
-        self.assertEqual(server_config.cwd, '/workspace')
-        self.assertEqual(server_config.enabled_tools, ['tool1', 'tool2'])
-        self.assertEqual(server_config.disabled_tools, ['tool3'])
-
-
 if __name__ == '__main__':
     unittest.main()
 

tests/test_mcp_cli_direct_management.py

@@ -40,19 +40,17 @@ class TestMCPConfigureCommand(unittest.TestCase):
                     try:
                         result = main()
                         # If main() returns without SystemExit, check the handler was called
-                        # Updated to include ALL host-specific parameters (27 total)
+                        # Updated to include ALL host-specific parameters
                         mock_handler.assert_called_once_with(
                             'claude-desktop', 'weather-server', 'python', ['weather.py'],
-                            None, None, None, None, False, None, None, None, None, None, None,
-                            False, None, None, None, None, None, False, None, None, False, False, False
+                            None, None, None, None, False, None, None, None, None, None, None, False, False, False
                         )
                     except SystemExit as e:
                         # If SystemExit is raised, it should be 0 (success) and handler should have been called
                         if e.code == 0:
                             mock_handler.assert_called_once_with(
                                 'claude-desktop', 'weather-server', 'python', ['weather.py'],
-                                None, None, None, None, False, None, None, None, None, None, None,
-                                False, None, None, None, None, None, False, None, None, False, False, False
+                                None, None, None, None, False, None, None, None, None, None, None, False, False, False
                             )
                         else:
                             self.fail(f"main() exited with code {e.code}, expected 0")
@@ -72,12 +70,11 @@ class TestMCPConfigureCommand(unittest.TestCase):
                 with patch('hatch.cli_hatch.handle_mcp_configure', return_value=0) as mock_handler:
                     try:
                         main()
-                        # Updated to include ALL host-specific parameters (27 total)
+                        # Updated to include ALL host-specific parameters
                         mock_handler.assert_called_once_with(
                             'cursor', 'file-server', None, None,
                             ['API_KEY=secret', 'DEBUG=true'], 'http://localhost:8080',
-                            ['Authorization=Bearer token'], None, False, None, None, None, None, None, None,
-                            False, None, None, None, None, None, False, None, None, True, True, True
+                            ['Authorization=Bearer token'], None, False, None, None, None, None, None, None, True, True, True
                         )
                     except SystemExit as e:
                         self.assertEqual(e.code, 0)