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

hatch/cli_hatch.py

@@ -716,12 +716,6 @@ 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,
@@ -843,27 +837,6 @@ 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
@@ -1595,13 +1568,11 @@ 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 [hosts: all]"
-    )
+    mcp_configure_parser.add_argument("server_name", help="Name for the MCP server")
     mcp_configure_parser.add_argument(
         "--host",
         required=True,
-        help="Host platform to configure (e.g., claude-desktop, cursor) [hosts: all]",
+        help="Host platform to configure (e.g., claude-desktop, cursor)",
     )
 
     # Create mutually exclusive group for server type
@@ -1609,125 +1580,89 @@ def main():
     server_type_group.add_argument(
         "--command",
         dest="server_command",
-        help="Command to execute the MCP server (for local servers) [hosts: all]",
+        help="Command to execute the MCP server (for local servers)",
     )
     server_type_group.add_argument(
-        "--url", help="Server URL for remote MCP servers (SSE transport) [hosts: all except claude-desktop, claude-code]"
+        "--url", help="Server URL for remote MCP servers (SSE transport)"
     )
     server_type_group.add_argument(
-        "--http-url", help="HTTP streaming endpoint URL [hosts: gemini]"
+        "--http-url", help="HTTP streaming endpoint URL (Gemini only)"
     )
 
     mcp_configure_parser.add_argument(
         "--args",
         nargs="*",
-        help="Arguments for the MCP server command (only with --command) [hosts: all]",
+        help="Arguments for the MCP server command (only with --command)",
     )
     mcp_configure_parser.add_argument(
-        "--env-var",
-        action="append",
-        help="Environment variables (format: KEY=VALUE) [hosts: all]",
+        "--env-var", action="append", help="Environment variables (format: KEY=VALUE)"
     )
     mcp_configure_parser.add_argument(
         "--header",
         action="append",
-        help="HTTP headers for remote servers (format: KEY=VALUE, only with --url) [hosts: all except claude-desktop, claude-code]",
+        help="HTTP headers for remote servers (format: KEY=VALUE, only with --url)",
     )
 
     # Host-specific arguments (Gemini)
     mcp_configure_parser.add_argument(
-        "--timeout", type=int, help="Request timeout in milliseconds [hosts: gemini]"
+        "--timeout", type=int, help="Request timeout in milliseconds (Gemini)"
     )
     mcp_configure_parser.add_argument(
-        "--trust", action="store_true", help="Bypass tool call confirmations [hosts: gemini]"
+        "--trust", action="store_true", help="Bypass tool call confirmations (Gemini)"
     )
     mcp_configure_parser.add_argument(
-        "--cwd", help="Working directory for stdio transport [hosts: gemini, codex]"
+        "--cwd", help="Working directory for stdio transport (Gemini)"
     )
     mcp_configure_parser.add_argument(
         "--include-tools",
         nargs="*",
-        help="Tool allowlist / enabled tools [hosts: gemini, codex]",
+        help="Tool allowlist - only these tools will be available (Gemini)",
     )
     mcp_configure_parser.add_argument(
         "--exclude-tools",
         nargs="*",
-        help="Tool blocklist / disabled tools [hosts: gemini, codex]",
+        help="Tool blocklist - these tools will be excluded (Gemini)",
     )
 
     # Host-specific arguments (Cursor/VS Code/LM Studio)
     mcp_configure_parser.add_argument(
-        "--env-file", help="Path to environment file [hosts: cursor, vscode, lmstudio]"
+        "--env-file", help="Path to environment file (Cursor, VS Code, LM Studio)"
     )
 
     # Host-specific arguments (VS Code)
     mcp_configure_parser.add_argument(
         "--input",
         action="append",
-        help="Input variable definitions in format: type,id,description[,password=true] [hosts: vscode]",
+        help="Input variable definitions in format: type,id,description[,password=true] (VS Code)",
     )
 
     # Host-specific arguments (Kiro)
     mcp_configure_parser.add_argument(
         "--disabled",
         action="store_true",
-        default=None,
-        help="Disable the MCP server [hosts: kiro]"
+        help="Disable the MCP server (Kiro)"
     )
     mcp_configure_parser.add_argument(
         "--auto-approve-tools",
         action="append",
-        help="Tool names to auto-approve without prompting [hosts: kiro]"
+        help="Tool names to auto-approve without prompting (Kiro)"
     )
     mcp_configure_parser.add_argument(
         "--disable-tools",
         action="append",
-        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]"
+        help="Tool names to disable (Kiro)"
     )
 
     mcp_configure_parser.add_argument(
         "--no-backup",
         action="store_true",
-        help="Skip backup creation before configuration [hosts: all]",
+        help="Skip backup creation before configuration",
     )
     mcp_configure_parser.add_argument(
-        "--dry-run", action="store_true", help="Preview configuration without execution [hosts: all]"
+        "--dry-run", action="store_true", help="Preview configuration without execution"
     )
     mcp_configure_parser.add_argument(
-        "--auto-approve", action="store_true", help="Skip confirmation prompts [hosts: all]"
+        "--auto-approve", action="store_true", help="Skip confirmation prompts"
     )
 
     # Remove MCP commands (object-action pattern)
@@ -2789,12 +2724,6 @@ 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,8 +11,7 @@ from .models import (
     PackageHostConfiguration, EnvironmentPackageEntry, ConfigurationResult, SyncResult,
     # Host-specific configuration models
     MCPServerConfigBase, MCPServerConfigGemini, MCPServerConfigVSCode,
-    MCPServerConfigCursor, MCPServerConfigClaude, MCPServerConfigKiro,
-    MCPServerConfigCodex, MCPServerConfigOmni,
+    MCPServerConfigCursor, MCPServerConfigClaude, MCPServerConfigKiro, MCPServerConfigOmni,
     HOST_MODEL_REGISTRY
 )
 from .host_management import (
@@ -31,8 +30,7 @@ __all__ = [
     'PackageHostConfiguration', 'EnvironmentPackageEntry', 'ConfigurationResult', 'SyncResult',
     # Host-specific configuration models
     'MCPServerConfigBase', 'MCPServerConfigGemini', 'MCPServerConfigVSCode',
-    'MCPServerConfigCursor', 'MCPServerConfigClaude', 'MCPServerConfigKiro',
-    'MCPServerConfigCodex', 'MCPServerConfigOmni',
+    'MCPServerConfigCursor', 'MCPServerConfigClaude', 'MCPServerConfigKiro', '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, Callable, TextIO
+from typing import Dict, List, Optional, Any
 
 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', 'codex'
+            'claude-desktop', 'claude-code', 'vscode', 
+            'cursor', 'lmstudio', 'gemini', 'kiro'
         }
         if v not in supported_hosts:
             raise ValueError(f"Unsupported hostname: {v}. Supported: {supported_hosts}")
@@ -53,9 +53,7 @@ class BackupInfo(BaseModel):
     @property
     def backup_name(self) -> str:
         """Get backup filename."""
-        # Extract original filename from backup path if available
-        # Backup filename format: {original_name}.{hostname}.{timestamp}
-        return self.file_path.name
+        return f"mcp.json.{self.hostname}.{self.timestamp.strftime('%Y%m%d_%H%M%S_%f')}"
     
     @property
     def age_days(self) -> int:
@@ -103,29 +101,22 @@ class BackupResult(BaseModel):
 
 class AtomicFileOperations:
     """Atomic file operations for safe configuration updates."""
-
-    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.
-
+    
+    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.
+        
         Args:
-            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
-
+            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
-
+            bool: True if operation successful, False otherwise
+            
         Raises:
             BackupError: If backup creation fails and skip_backup is False
         """
@@ -135,52 +126,32 @@ 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:
-                serializer(data, f)
-
+                json.dump(data, f, indent=2, ensure_ascii=False)
+            
+            # Atomic move to target location
             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
-
+                    pass  # Log but don't raise - original error is more important
+            
             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.
@@ -257,10 +228,8 @@ 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")
-            original_filename = config_path.name
-            backup_name = f"{original_filename}.{hostname}.{timestamp}"
+            backup_name = f"mcp.json.{hostname}.{timestamp}"
             backup_path = host_backup_dir / backup_name
             
             # Get original file size

hatch/mcp_host_config/models.py

@@ -25,7 +25,6 @@ class MCPHostType(str, Enum):
     LMSTUDIO = "lmstudio"
     GEMINI = "gemini"
     KIRO = "kiro"
-    CODEX = "codex"
 
 
 class MCPServerConfig(BaseModel):
@@ -542,108 +541,28 @@ 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.
 
@@ -692,17 +611,6 @@ 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):
@@ -722,5 +630,4 @@ HOST_MODEL_REGISTRY: Dict[MCPHostType, type[MCPServerConfigBase]] = {
     MCPHostType.CURSOR: MCPServerConfigCursor,
     MCPHostType.LMSTUDIO: MCPServerConfigCursor,  # Same as CURSOR
     MCPHostType.KIRO: MCPServerConfigKiro,
-    MCPHostType.CODEX: MCPServerConfigCodex,
 }