feat(codex): add MCPServerConfigCodex model and infrastructure

Add complete Codex MCP host support infrastructure:

- Add MCPHostType.CODEX enum value
- Add 'codex' to backup hostname validation
- Create MCPServerConfigCodex model with 10 Codex-specific fields:
  * env_vars: Environment variable whitelist
  * cwd: Working directory
  * startup_timeout_sec, tool_timeout_sec: Timeout controls
  * enabled: Server enable/disable flag
  * enabled_tools, disabled_tools: Tool filtering
  * bearer_token_env_var: Bearer token environment variable
  * http_headers, env_http_headers: HTTP authentication
- Extend MCPServerConfigOmni with all Codex fields
- Update HOST_MODEL_REGISTRY to map CODEX to model
- Export MCPServerConfigCodex from module
- Add atomic_write_with_serializer() method for format-agnostic writes
- Refactor atomic_write_with_backup() to use new serializer method

This enables TOML configuration support while maintaining backward
compatibility with existing JSON-based hosts.

Author: LittleCoinCoin

hatch/mcp_host_config/__init__.py

@@ -11,7 +11,8 @@
     PackageHostConfiguration, EnvironmentPackageEntry, ConfigurationResult, SyncResult,
     # Host-specific configuration models
     MCPServerConfigBase, MCPServerConfigGemini, MCPServerConfigVSCode,
-    MCPServerConfigCursor, MCPServerConfigClaude, MCPServerConfigKiro, MCPServerConfigOmni,
+    MCPServerConfigCursor, MCPServerConfigClaude, MCPServerConfigKiro,
+    MCPServerConfigCodex, MCPServerConfigOmni,
     HOST_MODEL_REGISTRY
 )
 from .host_management import (
@@ -30,7 +31,8 @@
     'PackageHostConfiguration', 'EnvironmentPackageEntry', 'ConfigurationResult', 'SyncResult',
     # Host-specific configuration models
     'MCPServerConfigBase', 'MCPServerConfigGemini', 'MCPServerConfigVSCode',
-    'MCPServerConfigCursor', 'MCPServerConfigClaude', 'MCPServerConfigKiro', 'MCPServerConfigOmni',
+    'MCPServerConfigCursor', 'MCPServerConfigClaude', 'MCPServerConfigKiro',
+    'MCPServerConfigCodex', 'MCPServerConfigOmni',
     'HOST_MODEL_REGISTRY',
     # User feedback reporting
     'FieldOperation', 'ConversionReport', 'generate_conversion_report', 'display_report',

hatch/mcp_host_config/backup.py

@@ -9,7 +9,7 @@
 import tempfile
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, List, Optional, Any
+from typing import Dict, List, Optional, Any, Callable, TextIO
 
 from pydantic import BaseModel, Field, validator
 
@@ -36,8 +36,8 @@ class BackupInfo(BaseModel):
     def validate_hostname(cls, v):
         """Validate hostname is supported."""
         supported_hosts = {
-            'claude-desktop', 'claude-code', 'vscode', 
-            'cursor', 'lmstudio', 'gemini', 'kiro'
+            'claude-desktop', 'claude-code', 'vscode',
+            'cursor', 'lmstudio', 'gemini', 'kiro', 'codex'
         }
         if v not in supported_hosts:
             raise ValueError(f"Unsupported hostname: {v}. Supported: {supported_hosts}")
@@ -101,22 +101,29 @@ class Config:
 
 class AtomicFileOperations:
     """Atomic file operations for safe configuration updates."""
-    
-    def atomic_write_with_backup(self, file_path: Path, data: Dict[str, Any], 
-                                backup_manager: "MCPHostConfigBackupManager", 
-                                hostname: str, skip_backup: bool = False) -> bool:
-        """Atomic write with automatic backup creation.
-        
+
+    def atomic_write_with_serializer(
+        self,
+        file_path: Path,
+        data: Any,
+        serializer: Callable[[Any, TextIO], None],
+        backup_manager: "MCPHostConfigBackupManager",
+        hostname: str,
+        skip_backup: bool = False
+    ) -> bool:
+        """Atomic write with custom serializer and automatic backup creation.
+
         Args:
-            file_path (Path): Target file path for writing
-            data (Dict[str, Any]): Data to write as JSON
-            backup_manager (MCPHostConfigBackupManager): Backup manager instance
-            hostname (str): Host identifier for backup
-            skip_backup (bool, optional): Skip backup creation. Defaults to False.
-            
+            file_path: Target file path for writing
+            data: Data to serialize and write
+            serializer: Function that writes data to file handle
+            backup_manager: Backup manager instance
+            hostname: Host identifier for backup
+            skip_backup: Skip backup creation
+
         Returns:
-            bool: True if operation successful, False otherwise
-            
+            bool: True if operation successful
+
         Raises:
             BackupError: If backup creation fails and skip_backup is False
         """
@@ -126,32 +133,52 @@ def atomic_write_with_backup(self, file_path: Path, data: Dict[str, Any],
             backup_result = backup_manager.create_backup(file_path, hostname)
             if not backup_result.success:
                 raise BackupError(f"Required backup failed: {backup_result.error_message}")
-        
-        # Create temporary file for atomic write
+
         temp_file = None
         try:
-            # Write to temporary file first
             temp_file = file_path.with_suffix(f"{file_path.suffix}.tmp")
             with open(temp_file, 'w', encoding='utf-8') as f:
-                json.dump(data, f, indent=2, ensure_ascii=False)
-            
-            # Atomic move to target location
+                serializer(data, f)
+
             temp_file.replace(file_path)
             return True
-            
+
         except Exception as e:
-            # Clean up temporary file on failure
             if temp_file and temp_file.exists():
                 temp_file.unlink()
-            
-            # Restore from backup if available
+
             if backup_result and backup_result.backup_path:
                 try:
                     backup_manager.restore_backup(hostname, backup_result.backup_path.name)
                 except Exception:
-                    pass  # Log but don't raise - original error is more important
-            
+                    pass
+
             raise BackupError(f"Atomic write failed: {str(e)}")
+
+    def atomic_write_with_backup(self, file_path: Path, data: Dict[str, Any],
+                                backup_manager: "MCPHostConfigBackupManager",
+                                hostname: str, skip_backup: bool = False) -> bool:
+        """Atomic write with JSON serialization (backward compatible).
+
+        Args:
+            file_path (Path): Target file path for writing
+            data (Dict[str, Any]): Data to write as JSON
+            backup_manager (MCPHostConfigBackupManager): Backup manager instance
+            hostname (str): Host identifier for backup
+            skip_backup (bool, optional): Skip backup creation. Defaults to False.
+
+        Returns:
+            bool: True if operation successful, False otherwise
+
+        Raises:
+            BackupError: If backup creation fails and skip_backup is False
+        """
+        def json_serializer(data: Any, f: TextIO) -> None:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+        return self.atomic_write_with_serializer(
+            file_path, data, json_serializer, backup_manager, hostname, skip_backup
+        )
 
     def atomic_copy(self, source: Path, target: Path) -> bool:
         """Atomic file copy operation.

hatch/mcp_host_config/models.py

@@ -25,6 +25,7 @@ class MCPHostType(str, Enum):
     LMSTUDIO = "lmstudio"
     GEMINI = "gemini"
     KIRO = "kiro"
+    CODEX = "codex"
 
 
 class MCPServerConfig(BaseModel):
@@ -541,28 +542,93 @@ def from_omni(cls, omni: 'MCPServerConfigOmni') -> 'MCPServerConfigClaude':
 
 class MCPServerConfigKiro(MCPServerConfigBase):
     """Kiro IDE-specific MCP server configuration.
-    
+
     Extends base model with Kiro-specific fields for server management
     and tool control.
     """
-    
+
     # Kiro-specific fields
     disabled: Optional[bool] = Field(None, description="Whether server is disabled")
     autoApprove: Optional[List[str]] = Field(None, description="Auto-approved tool names")
     disabledTools: Optional[List[str]] = Field(None, description="Disabled tool names")
-    
+
     @classmethod
     def from_omni(cls, omni: 'MCPServerConfigOmni') -> 'MCPServerConfigKiro':
         """Convert Omni model to Kiro-specific model."""
         # Get supported fields dynamically
         supported_fields = set(cls.model_fields.keys())
-        
+
         # Single-call field filtering
         kiro_data = omni.model_dump(include=supported_fields, exclude_unset=True)
-        
+
         return cls.model_validate(kiro_data)
 
 
+class MCPServerConfigCodex(MCPServerConfigBase):
+    """Codex-specific MCP server configuration.
+
+    Extends base model with Codex-specific fields including timeouts,
+    tool filtering, environment variable forwarding, and HTTP authentication.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    # Codex-specific STDIO fields
+    env_vars: Optional[List[str]] = Field(
+        None,
+        description="Environment variables to whitelist/forward"
+    )
+    cwd: Optional[str] = Field(
+        None,
+        description="Working directory to launch server from"
+    )
+
+    # Timeout configuration
+    startup_timeout_sec: Optional[int] = Field(
+        None,
+        description="Server startup timeout in seconds (default: 10)"
+    )
+    tool_timeout_sec: Optional[int] = Field(
+        None,
+        description="Tool execution timeout in seconds (default: 60)"
+    )
+
+    # Server control
+    enabled: Optional[bool] = Field(
+        None,
+        description="Enable/disable server without deleting config"
+    )
+    enabled_tools: Optional[List[str]] = Field(
+        None,
+        description="Allow-list of tools to expose from server"
+    )
+    disabled_tools: Optional[List[str]] = Field(
+        None,
+        description="Deny-list of tools to hide (applied after enabled_tools)"
+    )
+
+    # HTTP authentication fields
+    bearer_token_env_var: Optional[str] = Field(
+        None,
+        description="Name of env var containing bearer token for Authorization header"
+    )
+    http_headers: Optional[Dict[str, str]] = Field(
+        None,
+        description="Map of header names to static values"
+    )
+    env_http_headers: Optional[Dict[str, str]] = Field(
+        None,
+        description="Map of header names to env var names (values pulled from env)"
+    )
+
+    @classmethod
+    def from_omni(cls, omni: 'MCPServerConfigOmni') -> 'MCPServerConfigCodex':
+        """Convert Omni model to Codex-specific model."""
+        supported_fields = set(cls.model_fields.keys())
+        codex_data = omni.model_dump(include=supported_fields, exclude_unset=True)
+        return cls.model_validate(codex_data)
+
+
 class MCPServerConfigOmni(BaseModel):
     """Omni configuration supporting all host-specific fields.
 
@@ -611,6 +677,17 @@ class MCPServerConfigOmni(BaseModel):
     autoApprove: Optional[List[str]] = None
     disabledTools: Optional[List[str]] = None
 
+    # Codex specific
+    env_vars: Optional[List[str]] = None
+    startup_timeout_sec: Optional[int] = None
+    tool_timeout_sec: Optional[int] = None
+    enabled: Optional[bool] = None
+    enabled_tools: Optional[List[str]] = None
+    disabled_tools: Optional[List[str]] = None
+    bearer_token_env_var: Optional[str] = None
+    http_headers: Optional[Dict[str, str]] = None
+    env_http_headers: Optional[Dict[str, str]] = None
+
     @field_validator('url')
     @classmethod
     def validate_url_format(cls, v):
@@ -630,4 +707,5 @@ def validate_url_format(cls, v):
     MCPHostType.CURSOR: MCPServerConfigCursor,
     MCPHostType.LMSTUDIO: MCPServerConfigCursor,  # Same as CURSOR
     MCPHostType.KIRO: MCPServerConfigKiro,
+    MCPHostType.CODEX: MCPServerConfigCodex,
 }