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

hatch/mcp_host_config/strategies.py

@@ -8,8 +8,10 @@ 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
+from typing import Optional, Dict, Any, TextIO
 import logging
 
 from .host_management import MCPHostStrategy, register_host_strategy
@@ -607,3 +609,172 @@ 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.dev1.dist-info → hatch_xclam-0.7.1.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hatch-xclam
-Version: 0.7.1.dev1
+Version: 0.7.1.dev3
 Summary: Package manager for the Cracking Shells ecosystem
 Author: Cracking Shells Team
 Project-URL: Homepage, https://github.com/CrackingShells/Hatch
@@ -17,6 +17,7 @@ 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"
@@ -30,7 +31,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, 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, Codex, and other platforms with automatic dependency management.
 
 The canonical documentation is at `docs/index.md` and published at <https://hatch.readthedocs.io/en/latest/>.
 
@@ -38,7 +39,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** — Deploy MCP servers to Claude Desktop, Claude Code, VS Code, Cursor, Kiro, LM Studio, and Google Gemini CLI
+- **Multi-Host Deployment** — Configure MCP servers on multiple host platforms
 - **Package Validation** — Ensure packages meet schema requirements before distribution
 - **Development-Focused** — Optimized for rapid development and testing of MCP server ecosystems
 
@@ -51,6 +52,7 @@ 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.dev1.dist-info → hatch_xclam-0.7.1.dev3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 hatch/__init__.py,sha256=5JFQZiaZQewEWg8WktQKEdT8IeH0KstndZf27VH7sq4,594
-hatch/cli_hatch.py,sha256=mDWKVA8Cg8lpXElkJbj8-7xyzI1AiJk3nlp2kOtpwPk,109150
+hatch/cli_hatch.py,sha256=Z7-N0DdWT1xK23EL0Gr5mx2wjqhDFzFROt1nUxPAnZM,112093
 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=YZ9LEbR5E5p6padhPt114wvcsLCz16c2RPduhvvsj9I,1727
-hatch/mcp_host_config/backup.py,sha256=vl2YLL0P0bobGvx5moSAe4wI47vp25d-NpwNO95J3zU,16875
+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/host_management.py,sha256=sXyGluFQpfXKggxAVvV9riGRis29JnoEM2dTWSIwb24,23905
-hatch/mcp_host_config/models.py,sha256=OM5sKtQF-1hylXijNNRctKpHFQbPA88C3DorwyhGv20,25710
+hatch/mcp_host_config/models.py,sha256=1Nd3PDyGGbBm4oTgMEQ67j4b_qy23iibv9N4Tm4d9oE,29110
 hatch/mcp_host_config/reporting.py,sha256=Q8UKBJRfvJTbb5PM9xwLEOh3OJjf19AKpWKxs-2622k,6889
-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
+hatch/mcp_host_config/strategies.py,sha256=NdA8hcbAi5xGkFRy51csmdEJESg25L8JkwTDVg2AeMw,30302
+hatch_xclam-0.7.1.dev3.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=xLmWCgvupfYo5Z107rYyuz4VJdgWFAWBAw7eKokSscw,11302
+tests/test_mcp_cli_all_host_specific_args.py,sha256=hvXUetFyoZFtHsEjpzZ0GNdEuvci3Hv8P8thVjBPm-A,18748
 tests/test_mcp_cli_backup_management.py,sha256=GlUUNu5K1w8S2jTQ6YISp5KeXH5c-H9F0lJX2SG0JWM,14019
-tests/test_mcp_cli_direct_management.py,sha256=NOlRGP7M3CJ6dzR9JNtqIswJaCT8WIOoy2PhKXlGqSM,21906
+tests/test_mcp_cli_direct_management.py,sha256=7GRwHXezmImCUfpHhVjvSkGfT-OBi1tMMLgExMXjals,22184
 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,6 +59,9 @@ 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
@@ -95,8 +98,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.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,,
+hatch_xclam-0.7.1.dev3.dist-info/METADATA,sha256=-QwerIq3PVxHdoIVq32lneCmCgh2kQBHm9N1jrIAIdY,5947
+hatch_xclam-0.7.1.dev3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hatch_xclam-0.7.1.dev3.dist-info/entry_points.txt,sha256=6xbkwFUtr7nRa56vUFMyJk2wjwFQ_XVaU53ruecWKI0,47
+hatch_xclam-0.7.1.dev3.dist-info/top_level.txt,sha256=GZP3Ivciwal8jVITQkQr7dSNlLJRzfNOhA76VN7Jp4Y,12
+hatch_xclam-0.7.1.dev3.dist-info/RECORD,,

tests/regression/test_mcp_codex_backup_integration.py

@@ -0,0 +1,162 @@
+"""
+Codex MCP Backup Integration Tests
+
+Tests for Codex TOML backup integration including backup creation,
+restoration, and the no_backup parameter.
+"""
+
+import unittest
+import tempfile
+import tomllib
+from pathlib import Path
+
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.strategies import CodexHostStrategy
+from hatch.mcp_host_config.models import MCPServerConfig, HostConfiguration
+from hatch.mcp_host_config.backup import MCPHostConfigBackupManager, BackupInfo
+
+
+class TestCodexBackupIntegration(unittest.TestCase):
+    """Test suite for Codex backup integration."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        self.strategy = CodexHostStrategy()
+    
+    @regression_test
+    def test_write_configuration_creates_backup_by_default(self):
+        """Test that write_configuration creates backup by default when file exists."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "config.toml"
+            backup_dir = Path(tmpdir) / "backups"
+            
+            # Create initial config
+            initial_toml = """[mcp_servers.old-server]
+command = "old-command"
+"""
+            config_path.write_text(initial_toml)
+            
+            # Create new configuration
+            new_config = HostConfiguration(servers={
+                'new-server': MCPServerConfig(
+                    command='new-command',
+                    args=['--test']
+                )
+            })
+            
+            # Patch paths
+            from unittest.mock import patch
+            with patch.object(self.strategy, 'get_config_path', return_value=config_path):
+                with patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager') as MockBackupManager:
+                    # Create a real backup manager with custom backup dir
+                    real_backup_manager = MCPHostConfigBackupManager(backup_root=backup_dir)
+                    MockBackupManager.return_value = real_backup_manager
+                    
+                    # Write configuration (should create backup)
+                    success = self.strategy.write_configuration(new_config, no_backup=False)
+                    self.assertTrue(success)
+                    
+                    # Verify backup was created
+                    backup_files = list(backup_dir.glob('codex/*.toml.*'))
+                    self.assertGreater(len(backup_files), 0, "Backup file should be created")
+    
+    @regression_test
+    def test_write_configuration_skips_backup_when_requested(self):
+        """Test that write_configuration skips backup when no_backup=True."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "config.toml"
+            backup_dir = Path(tmpdir) / "backups"
+            
+            # Create initial config
+            initial_toml = """[mcp_servers.old-server]
+command = "old-command"
+"""
+            config_path.write_text(initial_toml)
+            
+            # Create new configuration
+            new_config = HostConfiguration(servers={
+                'new-server': MCPServerConfig(
+                    command='new-command'
+                )
+            })
+            
+            # Patch paths
+            from unittest.mock import patch
+            with patch.object(self.strategy, 'get_config_path', return_value=config_path):
+                with patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager') as MockBackupManager:
+                    real_backup_manager = MCPHostConfigBackupManager(backup_root=backup_dir)
+                    MockBackupManager.return_value = real_backup_manager
+                    
+                    # Write configuration with no_backup=True
+                    success = self.strategy.write_configuration(new_config, no_backup=True)
+                    self.assertTrue(success)
+                    
+                    # Verify no backup was created
+                    if backup_dir.exists():
+                        backup_files = list(backup_dir.glob('codex/*.toml.*'))
+                        self.assertEqual(len(backup_files), 0, "No backup should be created when no_backup=True")
+    
+    @regression_test
+    def test_write_configuration_no_backup_for_new_file(self):
+        """Test that no backup is created when writing to a new file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "config.toml"
+            backup_dir = Path(tmpdir) / "backups"
+            
+            # Don't create initial file - this is a new file
+            
+            # Create new configuration
+            new_config = HostConfiguration(servers={
+                'new-server': MCPServerConfig(
+                    command='new-command'
+                )
+            })
+            
+            # Patch paths
+            from unittest.mock import patch
+            with patch.object(self.strategy, 'get_config_path', return_value=config_path):
+                with patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager') as MockBackupManager:
+                    real_backup_manager = MCPHostConfigBackupManager(backup_root=backup_dir)
+                    MockBackupManager.return_value = real_backup_manager
+                    
+                    # Write configuration to new file
+                    success = self.strategy.write_configuration(new_config, no_backup=False)
+                    self.assertTrue(success)
+                    
+                    # Verify file was created
+                    self.assertTrue(config_path.exists())
+                    
+                    # Verify no backup was created (nothing to backup)
+                    if backup_dir.exists():
+                        backup_files = list(backup_dir.glob('codex/*.toml.*'))
+                        self.assertEqual(len(backup_files), 0, "No backup for new file")
+    
+    @regression_test
+    def test_codex_hostname_supported_in_backup_system(self):
+        """Test that 'codex' hostname is supported by the backup system."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "config.toml"
+            backup_dir = Path(tmpdir) / "backups"
+            
+            # Create a config file
+            config_path.write_text("[mcp_servers.test]\ncommand = 'test'\n")
+            
+            # Create backup manager
+            backup_manager = MCPHostConfigBackupManager(backup_root=backup_dir)
+            
+            # Create backup with 'codex' hostname - should not raise validation error
+            result = backup_manager.create_backup(config_path, 'codex')
+            
+            # Verify backup succeeded
+            self.assertTrue(result.success, "Backup with 'codex' hostname should succeed")
+            self.assertIsNotNone(result.backup_path)
+            
+            # Verify backup filename follows pattern
+            backup_filename = result.backup_path.name
+            self.assertTrue(backup_filename.startswith('config.toml.codex.'))
+
+
+if __name__ == '__main__':
+    unittest.main()
+

tests/regression/test_mcp_codex_host_strategy.py

@@ -0,0 +1,163 @@
+"""
+Codex MCP Host Strategy Tests
+
+Tests for CodexHostStrategy implementation including path resolution,
+configuration read/write, TOML handling, and host detection.
+"""
+
+import unittest
+import tempfile
+import tomllib
+from unittest.mock import patch, mock_open, MagicMock
+from pathlib import Path
+
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.strategies import CodexHostStrategy
+from hatch.mcp_host_config.models import MCPServerConfig, HostConfiguration
+
+# Import test data loader from local tests module
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from test_data_utils import MCPHostConfigTestDataLoader
+
+
+class TestCodexHostStrategy(unittest.TestCase):
+    """Test suite for CodexHostStrategy implementation."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        self.strategy = CodexHostStrategy()
+        self.test_data_loader = MCPHostConfigTestDataLoader()
+    
+    @regression_test
+    def test_codex_config_path_resolution(self):
+        """Test Codex configuration path resolution."""
+        config_path = self.strategy.get_config_path()
+        
+        # Verify path structure (use normalized path for cross-platform compatibility)
+        self.assertIsNotNone(config_path)
+        normalized_path = str(config_path).replace('\\', '/')
+        self.assertTrue(normalized_path.endswith('.codex/config.toml'))
+        self.assertEqual(config_path.name, 'config.toml')
+        self.assertEqual(config_path.suffix, '.toml')  # Verify TOML extension
+    
+    @regression_test
+    def test_codex_config_key(self):
+        """Test Codex configuration key."""
+        config_key = self.strategy.get_config_key()
+        # Codex uses underscore, not camelCase
+        self.assertEqual(config_key, "mcp_servers")
+        self.assertNotEqual(config_key, "mcpServers")  # Verify different from other hosts
+    
+    @regression_test
+    def test_codex_server_config_validation_stdio(self):
+        """Test Codex STDIO server configuration validation."""
+        # Test local server validation
+        local_config = MCPServerConfig(
+            command="npx",
+            args=["-y", "package"]
+        )
+        self.assertTrue(self.strategy.validate_server_config(local_config))
+    
+    @regression_test
+    def test_codex_server_config_validation_http(self):
+        """Test Codex HTTP server configuration validation."""
+        # Test remote server validation
+        remote_config = MCPServerConfig(
+            url="https://api.example.com/mcp"
+        )
+        self.assertTrue(self.strategy.validate_server_config(remote_config))
+    
+    @patch('pathlib.Path.exists')
+    @regression_test
+    def test_codex_host_availability_detection(self, mock_exists):
+        """Test Codex host availability detection."""
+        # Test when Codex directory exists
+        mock_exists.return_value = True
+        self.assertTrue(self.strategy.is_host_available())
+        
+        # Test when Codex directory doesn't exist
+        mock_exists.return_value = False
+        self.assertFalse(self.strategy.is_host_available())
+    
+    @regression_test
+    def test_codex_read_configuration_success(self):
+        """Test successful Codex TOML configuration reading."""
+        # Load test data
+        test_toml_path = Path(__file__).parent.parent / "test_data" / "codex" / "valid_config.toml"
+        
+        with patch.object(self.strategy, 'get_config_path', return_value=test_toml_path):
+            config = self.strategy.read_configuration()
+            
+            # Verify configuration was read
+            self.assertIsInstance(config, HostConfiguration)
+            self.assertIn('context7', config.servers)
+            
+            # Verify server details
+            server = config.servers['context7']
+            self.assertEqual(server.command, 'npx')
+            self.assertEqual(server.args, ['-y', '@upstash/context7-mcp'])
+            
+            # Verify nested env section was parsed correctly
+            self.assertIsNotNone(server.env)
+            self.assertEqual(server.env.get('MY_VAR'), 'value')
+    
+    @regression_test
+    def test_codex_read_configuration_file_not_exists(self):
+        """Test Codex configuration reading when file doesn't exist."""
+        non_existent_path = Path("/non/existent/path/config.toml")
+        
+        with patch.object(self.strategy, 'get_config_path', return_value=non_existent_path):
+            config = self.strategy.read_configuration()
+            
+            # Should return empty configuration without error
+            self.assertIsInstance(config, HostConfiguration)
+            self.assertEqual(len(config.servers), 0)
+    
+    @regression_test
+    def test_codex_write_configuration_preserves_features(self):
+        """Test that write_configuration preserves [features] section."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "config.toml"
+            
+            # Create initial config with features section
+            initial_toml = """[features]
+rmcp_client = true
+
+[mcp_servers.existing]
+command = "old-command"
+"""
+            config_path.write_text(initial_toml)
+            
+            # Create new configuration to write
+            new_config = HostConfiguration(servers={
+                'new-server': MCPServerConfig(
+                    command='new-command',
+                    args=['--test']
+                )
+            })
+            
+            # Write configuration
+            with patch.object(self.strategy, 'get_config_path', return_value=config_path):
+                success = self.strategy.write_configuration(new_config, no_backup=True)
+                self.assertTrue(success)
+            
+            # Read back and verify features section preserved
+            with open(config_path, 'rb') as f:
+                result_data = tomllib.load(f)
+            
+            # Verify features section preserved
+            self.assertIn('features', result_data)
+            self.assertTrue(result_data['features'].get('rmcp_client'))
+            
+            # Verify new server added
+            self.assertIn('mcp_servers', result_data)
+            self.assertIn('new-server', result_data['mcp_servers'])
+            self.assertEqual(result_data['mcp_servers']['new-server']['command'], 'new-command')
+
+
+if __name__ == '__main__':
+    unittest.main()
+