hatch-xclam 0.7.0.dev13__py3-none-any.whl → 0.7.1__py3-none-any.whl

hatch/mcp_host_config/strategies.py

@@ -8,12 +8,15 @@ 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
 from .models import MCPHostType, MCPServerConfig, HostConfiguration
+from .backup import MCPHostConfigBackupManager, AtomicFileOperations
 
 logger = logging.getLogger(__name__)
 
@@ -409,6 +412,101 @@ class VSCodeHostStrategy(MCPHostStrategy):
             return False
 
 
+@register_host_strategy(MCPHostType.KIRO)
+class KiroHostStrategy(MCPHostStrategy):
+    """Configuration strategy for Kiro IDE."""
+    
+    def get_config_path(self) -> Optional[Path]:
+        """Get Kiro configuration path (user-level only per constraint)."""
+        return Path.home() / ".kiro" / "settings" / "mcp.json"
+    
+    def get_config_key(self) -> str:
+        """Kiro uses 'mcpServers' key."""
+        return "mcpServers"
+    
+    def is_host_available(self) -> bool:
+        """Check if Kiro is available by checking for settings directory."""
+        kiro_dir = Path.home() / ".kiro" / "settings"
+        return kiro_dir.exists()
+    
+    def validate_server_config(self, server_config: MCPServerConfig) -> bool:
+        """Kiro validation - supports both local and remote servers."""
+        return server_config.command is not None or server_config.url is not None
+    
+    def read_configuration(self) -> HostConfiguration:
+        """Read Kiro configuration file."""
+        config_path_str = self.get_config_path()
+        if not config_path_str:
+            return HostConfiguration(servers={})
+        
+        config_path = Path(config_path_str)
+        if not config_path.exists():
+            return HostConfiguration(servers={})
+        
+        try:
+            with open(config_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            servers = {}
+            mcp_servers = data.get(self.get_config_key(), {})
+            
+            for name, config in mcp_servers.items():
+                try:
+                    servers[name] = MCPServerConfig(**config)
+                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 Kiro configuration: {e}")
+            return HostConfiguration(servers={})
+    
+    def write_configuration(self, config: HostConfiguration, no_backup: bool = False) -> bool:
+        """Write configuration to Kiro with backup support."""
+        config_path_str = self.get_config_path()
+        if not config_path_str:
+            return False
+        
+        config_path = Path(config_path_str)
+        
+        try:
+            # Ensure directory exists
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Read existing configuration to preserve other settings
+            existing_data = {}
+            if config_path.exists():
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    existing_data = json.load(f)
+            
+            # Update MCP servers section
+            servers_data = {}
+            for name, server_config in config.servers.items():
+                servers_data[name] = server_config.model_dump(exclude_unset=True)
+            
+            existing_data[self.get_config_key()] = servers_data
+            
+            # Use atomic write with backup support
+            backup_manager = MCPHostConfigBackupManager()
+            atomic_ops = AtomicFileOperations()
+            
+            atomic_ops.atomic_write_with_backup(
+                file_path=config_path,
+                data=existing_data,
+                backup_manager=backup_manager,
+                hostname="kiro",
+                skip_backup=no_backup
+            )
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to write Kiro configuration: {e}")
+            return False
+
+
 @register_host_strategy(MCPHostType.GEMINI)
 class GeminiHostStrategy(MCPHostStrategy):
     """Configuration strategy for Google Gemini CLI MCP integration."""
@@ -511,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.0.dev13.dist-info → hatch_xclam-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hatch-xclam
-Version: 0.7.0.dev13
+Version: 0.7.1
 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, 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, 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
 
@@ -50,6 +51,8 @@ Hatch supports deployment to the following MCP host platforms:
 - **Claude Code** — Claude integration for VS Code with MCP capabilities
 - **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.0.dev13.dist-info → hatch_xclam-0.7.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 hatch/__init__.py,sha256=5JFQZiaZQewEWg8WktQKEdT8IeH0KstndZf27VH7sq4,594
-hatch/cli_hatch.py,sha256=kwTUTUqwI0SbAmyjeRFoj5ppLG90hJf7Pb4chPb7jvI,108041
+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,17 +15,17 @@ 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=WtN_wZVqSrzgcSzmL00I4Qh7_MKjtRlNhWLQ4JinP1o,1683
-hatch/mcp_host_config/backup.py,sha256=h3jssjEQxIsEPcpW07WSEJNcPvQ5ps-83_YtVuek-eg,16867
+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=WLAdeJc-t4zyiiHByQHYGpC55t6ViggBAs4N1ksJ6W8,24548
+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=deFdAbj8G6Mzs7W8fBlPMPnijxzSnQ2SS5AAx0JR6oY,20293
-hatch_xclam-0.7.0.dev13.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+hatch/mcp_host_config/strategies.py,sha256=NdA8hcbAi5xGkFRy51csmdEJESg25L8JkwTDVg2AeMw,30302
+hatch_xclam-0.7.1.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
-tests/test_data_utils.py,sha256=OjT4rVUxHAe-d1fIuG-4iMicM1uuadsWsKjqRzYlGtY,17752
+tests/test_data_utils.py,sha256=ROexE3H4Cjk8maR-r6x8s5507d0vWF5xJteO_YN78SU,21876
 tests/test_dependency_orchestrator_consent.py,sha256=lA9Qu-3dFdXKmU8mzOS0tjM8j0yy9qMQXJJcgEoy12g,12652
 tests/test_docker_installer.py,sha256=pcWev4fGf1p-pR5T8tDswGVZqIprC86puLEl6t8yY2w,22305
 tests/test_env_manip.py,sha256=f3LjBX0y0wzTDjc52QDan3Fgcgtld7CvuzH5gYKxGhs,47941
@@ -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
@@ -56,6 +56,18 @@ tests/test_python_installer.py,sha256=DXBy7hNJk5313_dDXiHTLEH7UJSPUnyGs4IEr7Hn_5
 tests/test_registry.py,sha256=nFHwRIx9n8y0nHwW9j8X3DZ07Y0BLYZMKduTXo-xXTc,2261
 tests/test_registry_retriever.py,sha256=6mQQuqy2tQdw4j3VOkC_DxWqtKwaCjGPgXsdL-w48Yw,10775
 tests/test_system_installer.py,sha256=bWuyEKakhvi51iM8xHJh62zv83HUTd8QnPlqUUMWx9c,28102
+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
+tests/regression/test_mcp_kiro_host_strategy.py,sha256=t3EbNgUkDC-tF_Ztrjlrx8aDkmML2zZiPnl3iLvKWcg,8235
+tests/regression/test_mcp_kiro_model_validation.py,sha256=bCWzkP6gDxD4tJ6bXnyC6BNGPk3FwX5MQVJt_kK-Hsg,3877
+tests/regression/test_mcp_kiro_omni_conversion.py,sha256=u0g-NFKDpyVxguNHc_RxJXhBvUvABljx-IZqeOjpJZw,3559
 tests/test_data/packages/basic/base_pkg/hatch_mcp_server.py,sha256=nn9XJQz7Owq_AKZ35bUV-l5eThauxTvIQZdQmcZqbQg,350
 tests/test_data/packages/basic/base_pkg/mcp_server.py,sha256=gzXj-n0NbcS1TF-ebKOdXQRyuVIC0Gn_b8ZB-9RckrM,422
 tests/test_data/packages/basic/base_pkg_v2/hatch_mcp_server.py,sha256=VmGpeLPpsNyFyePNtcRQCSscLOHdZgXsGDulA4_9CJA,356
@@ -86,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.0.dev13.dist-info/METADATA,sha256=kPUoyD_oOKbFW6zIP8iepiZ217Tk9LG13Vv3pgnt0Vw,5849
-hatch_xclam-0.7.0.dev13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hatch_xclam-0.7.0.dev13.dist-info/entry_points.txt,sha256=6xbkwFUtr7nRa56vUFMyJk2wjwFQ_XVaU53ruecWKI0,47
-hatch_xclam-0.7.0.dev13.dist-info/top_level.txt,sha256=GZP3Ivciwal8jVITQkQr7dSNlLJRzfNOhA76VN7Jp4Y,12
-hatch_xclam-0.7.0.dev13.dist-info/RECORD,,
+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,,

tests/integration/__init__.py

@@ -0,0 +1,5 @@
+"""
+Integration tests for Hatch MCP functionality.
+
+These tests validate component interactions and end-to-end workflows.
+"""

tests/integration/test_mcp_kiro_integration.py

@@ -0,0 +1,153 @@
+"""
+Kiro MCP Integration Tests
+
+End-to-end integration tests combining CLI, model conversion, and strategy operations.
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+
+from wobble.decorators import integration_test
+
+from hatch.cli_hatch import handle_mcp_configure
+from hatch.mcp_host_config.models import (
+    HOST_MODEL_REGISTRY,
+    MCPHostType,
+    MCPServerConfigKiro
+)
+
+
+class TestKiroIntegration(unittest.TestCase):
+    """Test suite for end-to-end Kiro integration."""
+    
+    @integration_test(scope="component")
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    def test_kiro_end_to_end_configuration(self, mock_manager_class):
+        """Test complete Kiro configuration workflow."""
+        # Setup mocks
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_manager.configure_server.return_value = mock_result
+        
+        # Execute CLI command with Kiro-specific arguments
+        result = handle_mcp_configure(
+            host='kiro',
+            server_name='augment-server',
+            command='auggie',
+            args=['--mcp', '-m', 'default'],
+            disabled=False,
+            auto_approve_tools=['codebase-retrieval', 'fetch'],
+            disable_tools=['dangerous-tool'],
+            auto_approve=True
+        )
+        
+        # Verify success
+        self.assertEqual(result, 0)
+        
+        # Verify configuration manager was called
+        mock_manager.configure_server.assert_called_once()
+        
+        # Verify server configuration
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        
+        # Verify all Kiro-specific fields
+        self.assertFalse(server_config.disabled)
+        self.assertEqual(len(server_config.autoApprove), 2)
+        self.assertEqual(len(server_config.disabledTools), 1)
+        self.assertIn('codebase-retrieval', server_config.autoApprove)
+        self.assertIn('dangerous-tool', server_config.disabledTools)
+    
+    @integration_test(scope="system")
+    def test_kiro_host_model_registry_integration(self):
+        """Test Kiro integration with HOST_MODEL_REGISTRY."""
+        # Verify Kiro is in registry
+        self.assertIn(MCPHostType.KIRO, HOST_MODEL_REGISTRY)
+        
+        # Verify correct model class
+        model_class = HOST_MODEL_REGISTRY[MCPHostType.KIRO]
+        self.assertEqual(model_class.__name__, "MCPServerConfigKiro")
+        
+        # Test model instantiation
+        model_instance = model_class(
+            name="test-server",
+            command="auggie",
+            disabled=True
+        )
+        self.assertTrue(model_instance.disabled)
+    
+    @integration_test(scope="component")
+    def test_kiro_model_to_strategy_workflow(self):
+        """Test workflow from model creation to strategy operations."""
+        # Import to trigger registration
+        import hatch.mcp_host_config.strategies
+        from hatch.mcp_host_config.host_management import MCPHostRegistry
+        
+        # Create Kiro model
+        kiro_model = MCPServerConfigKiro(
+            name="workflow-test",
+            command="auggie",
+            args=["--mcp"],
+            disabled=False,
+            autoApprove=["codebase-retrieval"]
+        )
+        
+        # Get Kiro strategy
+        strategy = MCPHostRegistry.get_strategy(MCPHostType.KIRO)
+        
+        # Verify strategy can validate the model
+        self.assertTrue(strategy.validate_server_config(kiro_model))
+        
+        # Verify model fields are accessible
+        self.assertEqual(kiro_model.command, "auggie")
+        self.assertFalse(kiro_model.disabled)
+        self.assertIn("codebase-retrieval", kiro_model.autoApprove)
+    
+    @integration_test(scope="end_to_end")
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    def test_kiro_complete_lifecycle(self, mock_manager_class):
+        """Test complete Kiro server lifecycle: create, configure, validate."""
+        # Setup mocks
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_manager.configure_server.return_value = mock_result
+        
+        # Step 1: Configure server via CLI
+        result = handle_mcp_configure(
+            host='kiro',
+            server_name='lifecycle-test',
+            command='auggie',
+            args=['--mcp', '-w', '.'],
+            disabled=False,
+            auto_approve_tools=['codebase-retrieval'],
+            auto_approve=True
+        )
+        
+        # Verify CLI success
+        self.assertEqual(result, 0)
+        
+        # Step 2: Verify configuration manager interaction
+        mock_manager.configure_server.assert_called_once()
+        call_args = mock_manager.configure_server.call_args
+        
+        # Step 3: Verify server configuration structure
+        server_config = call_args.kwargs['server_config']
+        self.assertEqual(server_config.name, 'lifecycle-test')
+        self.assertEqual(server_config.command, 'auggie')
+        self.assertIn('--mcp', server_config.args)
+        self.assertIn('-w', server_config.args)
+        self.assertFalse(server_config.disabled)
+        self.assertIn('codebase-retrieval', server_config.autoApprove)
+        
+        # Step 4: Verify model type
+        self.assertIsInstance(server_config, MCPServerConfigKiro)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/regression/__init__.py

@@ -0,0 +1,5 @@
+"""
+Regression tests for Hatch MCP functionality.
+
+These tests validate existing functionality to prevent breaking changes.
+"""