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

hatch/cli_hatch.py

@@ -716,6 +716,12 @@ def handle_mcp_configure(
     disabled: Optional[bool] = None,
     auto_approve_tools: Optional[list] = None,
     disable_tools: Optional[list] = None,
+    env_vars: Optional[list] = None,
+    startup_timeout: Optional[int] = None,
+    tool_timeout: Optional[int] = None,
+    enabled: Optional[bool] = None,
+    bearer_token_env_var: Optional[str] = None,
+    env_header: Optional[list] = None,
     no_backup: bool = False,
     dry_run: bool = False,
     auto_approve: bool = False,
@@ -837,6 +843,27 @@ def handle_mcp_configure(
         if disable_tools is not None:
             omni_config_data["disabledTools"] = disable_tools
 
+        # Host-specific fields (Codex)
+        if env_vars is not None:
+            omni_config_data["env_vars"] = env_vars
+        if startup_timeout is not None:
+            omni_config_data["startup_timeout_sec"] = startup_timeout
+        if tool_timeout is not None:
+            omni_config_data["tool_timeout_sec"] = tool_timeout
+        if enabled is not None:
+            omni_config_data["enabled"] = enabled
+        if bearer_token_env_var is not None:
+            omni_config_data["bearer_token_env_var"] = bearer_token_env_var
+        if env_header is not None:
+            # Parse KEY=ENV_VAR_NAME format into dict
+            env_http_headers = {}
+            for header_spec in env_header:
+                if '=' in header_spec:
+                    key, env_var_name = header_spec.split('=', 1)
+                    env_http_headers[key] = env_var_name
+            if env_http_headers:
+                omni_config_data["env_http_headers"] = env_http_headers
+
         # Partial update merge logic
         if is_update:
             # Merge with existing configuration
@@ -1568,11 +1595,13 @@ def main():
     mcp_configure_parser = mcp_subparsers.add_parser(
         "configure", help="Configure MCP server directly on host"
     )
-    mcp_configure_parser.add_argument("server_name", help="Name for the MCP server")
+    mcp_configure_parser.add_argument(
+        "server_name", help="Name for the MCP server [hosts: all]"
+    )
     mcp_configure_parser.add_argument(
         "--host",
         required=True,
-        help="Host platform to configure (e.g., claude-desktop, cursor)",
+        help="Host platform to configure (e.g., claude-desktop, cursor) [hosts: all]",
     )
 
     # Create mutually exclusive group for server type
@@ -1580,89 +1609,125 @@ def main():
     server_type_group.add_argument(
         "--command",
         dest="server_command",
-        help="Command to execute the MCP server (for local servers)",
+        help="Command to execute the MCP server (for local servers) [hosts: all]",
     )
     server_type_group.add_argument(
-        "--url", help="Server URL for remote MCP servers (SSE transport)"
+        "--url", help="Server URL for remote MCP servers (SSE transport) [hosts: all except claude-desktop, claude-code]"
     )
     server_type_group.add_argument(
-        "--http-url", help="HTTP streaming endpoint URL (Gemini only)"
+        "--http-url", help="HTTP streaming endpoint URL [hosts: gemini]"
     )
 
     mcp_configure_parser.add_argument(
         "--args",
         nargs="*",
-        help="Arguments for the MCP server command (only with --command)",
+        help="Arguments for the MCP server command (only with --command) [hosts: all]",
     )
     mcp_configure_parser.add_argument(
-        "--env-var", action="append", help="Environment variables (format: KEY=VALUE)"
+        "--env-var",
+        action="append",
+        help="Environment variables (format: KEY=VALUE) [hosts: all]",
     )
     mcp_configure_parser.add_argument(
         "--header",
         action="append",
-        help="HTTP headers for remote servers (format: KEY=VALUE, only with --url)",
+        help="HTTP headers for remote servers (format: KEY=VALUE, only with --url) [hosts: all except claude-desktop, claude-code]",
     )
 
     # Host-specific arguments (Gemini)
     mcp_configure_parser.add_argument(
-        "--timeout", type=int, help="Request timeout in milliseconds (Gemini)"
+        "--timeout", type=int, help="Request timeout in milliseconds [hosts: gemini]"
     )
     mcp_configure_parser.add_argument(
-        "--trust", action="store_true", help="Bypass tool call confirmations (Gemini)"
+        "--trust", action="store_true", help="Bypass tool call confirmations [hosts: gemini]"
     )
     mcp_configure_parser.add_argument(
-        "--cwd", help="Working directory for stdio transport (Gemini)"
+        "--cwd", help="Working directory for stdio transport [hosts: gemini, codex]"
     )
     mcp_configure_parser.add_argument(
         "--include-tools",
         nargs="*",
-        help="Tool allowlist - only these tools will be available (Gemini)",
+        help="Tool allowlist / enabled tools [hosts: gemini, codex]",
     )
     mcp_configure_parser.add_argument(
         "--exclude-tools",
         nargs="*",
-        help="Tool blocklist - these tools will be excluded (Gemini)",
+        help="Tool blocklist / disabled tools [hosts: gemini, codex]",
     )
 
     # Host-specific arguments (Cursor/VS Code/LM Studio)
     mcp_configure_parser.add_argument(
-        "--env-file", help="Path to environment file (Cursor, VS Code, LM Studio)"
+        "--env-file", help="Path to environment file [hosts: cursor, vscode, lmstudio]"
     )
 
     # Host-specific arguments (VS Code)
     mcp_configure_parser.add_argument(
         "--input",
         action="append",
-        help="Input variable definitions in format: type,id,description[,password=true] (VS Code)",
+        help="Input variable definitions in format: type,id,description[,password=true] [hosts: vscode]",
     )
 
     # Host-specific arguments (Kiro)
     mcp_configure_parser.add_argument(
         "--disabled",
         action="store_true",
-        help="Disable the MCP server (Kiro)"
+        default=None,
+        help="Disable the MCP server [hosts: kiro]"
     )
     mcp_configure_parser.add_argument(
         "--auto-approve-tools",
         action="append",
-        help="Tool names to auto-approve without prompting (Kiro)"
+        help="Tool names to auto-approve without prompting [hosts: kiro]"
     )
     mcp_configure_parser.add_argument(
         "--disable-tools",
         action="append",
-        help="Tool names to disable (Kiro)"
+        help="Tool names to disable [hosts: kiro]"
+    )
+
+    # Codex-specific arguments
+    mcp_configure_parser.add_argument(
+        "--env-vars",
+        action="append",
+        help="Environment variable names to whitelist/forward [hosts: codex]"
+    )
+    mcp_configure_parser.add_argument(
+        "--startup-timeout",
+        type=int,
+        help="Server startup timeout in seconds (default: 10) [hosts: codex]"
+    )
+    mcp_configure_parser.add_argument(
+        "--tool-timeout",
+        type=int,
+        help="Tool execution timeout in seconds (default: 60) [hosts: codex]"
+    )
+    mcp_configure_parser.add_argument(
+        "--enabled",
+        action="store_true",
+        default=None,
+        help="Enable the MCP server [hosts: codex]"
+    )
+    mcp_configure_parser.add_argument(
+        "--bearer-token-env-var",
+        type=str,
+        help="Name of environment variable containing bearer token for Authorization header [hosts: codex]"
+    )
+    mcp_configure_parser.add_argument(
+        "--env-header",
+        action="append",
+        help="HTTP header from environment variable in KEY=ENV_VAR_NAME format [hosts: codex]"
     )
 
     mcp_configure_parser.add_argument(
         "--no-backup",
         action="store_true",
-        help="Skip backup creation before configuration",
+        help="Skip backup creation before configuration [hosts: all]",
     )
     mcp_configure_parser.add_argument(
-        "--dry-run", action="store_true", help="Preview configuration without execution"
+        "--dry-run", action="store_true", help="Preview configuration without execution [hosts: all]"
     )
     mcp_configure_parser.add_argument(
-        "--auto-approve", action="store_true", help="Skip confirmation prompts"
+        "--auto-approve", action="store_true", help="Skip confirmation prompts [hosts: all]"
     )
 
     # Remove MCP commands (object-action pattern)
@@ -2724,6 +2789,12 @@ def main():
                 getattr(args, "disabled", None),
                 getattr(args, "auto_approve_tools", None),
                 getattr(args, "disable_tools", None),
+                getattr(args, "env_vars", None),
+                getattr(args, "startup_timeout", None),
+                getattr(args, "tool_timeout", None),
+                getattr(args, "enabled", None),
+                getattr(args, "bearer_token_env_var", None),
+                getattr(args, "env_header", None),
                 args.no_backup,
                 args.dry_run,
                 args.auto_approve,

hatch/mcp_host_config/__init__.py

@@ -11,7 +11,8 @@ from .models import (
     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 @@ __all__ = [
     '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 shutil
 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}")
@@ -53,7 +53,9 @@ class BackupInfo(BaseModel):
     @property
     def backup_name(self) -> str:
         """Get backup filename."""
-        return f"mcp.json.{self.hostname}.{self.timestamp.strftime('%Y%m%d_%H%M%S_%f')}"
+        # Extract original filename from backup path if available
+        # Backup filename format: {original_name}.{hostname}.{timestamp}
+        return self.file_path.name
     
     @property
     def age_days(self) -> int:
@@ -101,22 +103,29 @@ class BackupResult(BaseModel):
 
 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 +135,52 @@ class AtomicFileOperations:
             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.
@@ -228,8 +257,10 @@ class MCPHostConfigBackupManager:
             host_backup_dir.mkdir(exist_ok=True)
             
             # Generate timestamped backup filename with microseconds for uniqueness
+            # Preserve original filename instead of hardcoding 'mcp.json'
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
-            backup_name = f"mcp.json.{hostname}.{timestamp}"
+            original_filename = config_path.name
+            backup_name = f"{original_filename}.{hostname}.{timestamp}"
             backup_path = host_backup_dir / backup_name
             
             # Get original file size

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,108 @@ class MCPServerConfigClaude(MCPServerConfigBase):
 
 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.
+
+        Maps universal 'headers' field to Codex-specific 'http_headers' field.
+        """
+        supported_fields = set(cls.model_fields.keys())
+        codex_data = omni.model_dump(include=supported_fields, exclude_unset=True)
+
+        # Map shared CLI tool filtering flags (Gemini naming) to Codex naming.
+        # This lets `--include-tools/--exclude-tools` work for both Gemini and Codex.
+        if getattr(omni, 'includeTools', None) is not None and codex_data.get('enabled_tools') is None:
+            codex_data['enabled_tools'] = omni.includeTools
+        if getattr(omni, 'excludeTools', None) is not None and codex_data.get('disabled_tools') is None:
+            codex_data['disabled_tools'] = omni.excludeTools
+
+        # Map universal 'headers' to Codex 'http_headers'
+        if hasattr(omni, 'headers') and omni.headers is not None:
+            codex_data['http_headers'] = omni.headers
+
+        return cls.model_validate(codex_data)
+
+
 class MCPServerConfigOmni(BaseModel):
     """Omni configuration supporting all host-specific fields.
 
@@ -611,6 +692,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
+    env_http_headers: Optional[Dict[str, str]] = None
+    # Note: http_headers maps to universal 'headers' field, not a separate Codex field
+
     @field_validator('url')
     @classmethod
     def validate_url_format(cls, v):
@@ -630,4 +722,5 @@ HOST_MODEL_REGISTRY: Dict[MCPHostType, type[MCPServerConfigBase]] = {
     MCPHostType.CURSOR: MCPServerConfigCursor,
     MCPHostType.LMSTUDIO: MCPServerConfigCursor,  # Same as CURSOR
     MCPHostType.KIRO: MCPServerConfigKiro,
+    MCPHostType.CODEX: MCPServerConfigCodex,
 }