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

hatch/cli_hatch.py

@@ -713,6 +713,9 @@ def handle_mcp_configure(
     include_tools: Optional[list] = None,
     exclude_tools: Optional[list] = None,
     input: Optional[list] = None,
+    disabled: Optional[bool] = None,
+    auto_approve_tools: Optional[list] = None,
+    disable_tools: Optional[list] = None,
     no_backup: bool = False,
     dry_run: bool = False,
     auto_approve: bool = False,
@@ -826,6 +829,14 @@ def handle_mcp_configure(
         if inputs_list is not None:
             omni_config_data["inputs"] = inputs_list
 
+        # Host-specific fields (Kiro)
+        if disabled is not None:
+            omni_config_data["disabled"] = disabled
+        if auto_approve_tools is not None:
+            omni_config_data["autoApprove"] = auto_approve_tools
+        if disable_tools is not None:
+            omni_config_data["disabledTools"] = disable_tools
+
         # Partial update merge logic
         if is_update:
             # Merge with existing configuration
@@ -1625,6 +1636,23 @@ def main():
         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",
+        help="Disable the MCP server (Kiro)"
+    )
+    mcp_configure_parser.add_argument(
+        "--auto-approve-tools",
+        action="append",
+        help="Tool names to auto-approve without prompting (Kiro)"
+    )
+    mcp_configure_parser.add_argument(
+        "--disable-tools",
+        action="append",
+        help="Tool names to disable (Kiro)"
+    )
+
     mcp_configure_parser.add_argument(
         "--no-backup",
         action="store_true",
@@ -2693,6 +2721,9 @@ def main():
                 getattr(args, "include_tools", None),
                 getattr(args, "exclude_tools", None),
                 getattr(args, "input", None),
+                getattr(args, "disabled", None),
+                getattr(args, "auto_approve_tools", None),
+                getattr(args, "disable_tools", None),
                 args.no_backup,
                 args.dry_run,
                 args.auto_approve,

hatch/mcp_host_config/__init__.py

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

hatch/mcp_host_config/backup.py

@@ -37,7 +37,7 @@ class BackupInfo(BaseModel):
         """Validate hostname is supported."""
         supported_hosts = {
             'claude-desktop', 'claude-code', 'vscode', 
-            'cursor', 'lmstudio', 'gemini'
+            'cursor', 'lmstudio', 'gemini', 'kiro'
         }
         if v not in supported_hosts:
             raise ValueError(f"Unsupported hostname: {v}. Supported: {supported_hosts}")

hatch/mcp_host_config/models.py

@@ -24,6 +24,7 @@ class MCPHostType(str, Enum):
     CURSOR = "cursor"
     LMSTUDIO = "lmstudio"
     GEMINI = "gemini"
+    KIRO = "kiro"
 
 
 class MCPServerConfig(BaseModel):
@@ -192,7 +193,7 @@ class EnvironmentPackageEntry(BaseModel):
         """Validate host names are supported."""
         supported_hosts = {
             'claude-desktop', 'claude-code', 'vscode',
-            'cursor', 'lmstudio', 'gemini'
+            'cursor', 'lmstudio', 'gemini', 'kiro'
         }
         for host_name in v.keys():
             if host_name not in supported_hosts:
@@ -538,6 +539,30 @@ class MCPServerConfigClaude(MCPServerConfigBase):
         return cls.model_validate(claude_data)
 
 
+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 MCPServerConfigOmni(BaseModel):
     """Omni configuration supporting all host-specific fields.
 
@@ -580,6 +605,11 @@ class MCPServerConfigOmni(BaseModel):
     # VS Code specific
     envFile: Optional[str] = None
     inputs: Optional[List[Dict]] = None
+    
+    # Kiro specific
+    disabled: Optional[bool] = None
+    autoApprove: Optional[List[str]] = None
+    disabledTools: Optional[List[str]] = None
 
     @field_validator('url')
     @classmethod
@@ -599,4 +629,5 @@ HOST_MODEL_REGISTRY: Dict[MCPHostType, type[MCPServerConfigBase]] = {
     MCPHostType.VSCODE: MCPServerConfigVSCode,
     MCPHostType.CURSOR: MCPServerConfigCursor,
     MCPHostType.LMSTUDIO: MCPServerConfigCursor,  # Same as CURSOR
+    MCPHostType.KIRO: MCPServerConfigKiro,
 }

hatch/mcp_host_config/strategies.py

@@ -14,6 +14,7 @@ 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 +410,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."""

{hatch_xclam-0.7.0.dev13.dist-info → hatch_xclam-0.7.1.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hatch-xclam
-Version: 0.7.0.dev13
+Version: 0.7.1.dev1
 Summary: Package manager for the Cracking Shells ecosystem
 Author: Cracking Shells Team
 Project-URL: Homepage, https://github.com/CrackingShells/Hatch
@@ -30,7 +30,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, 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 +38,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** — Deploy MCP servers to Claude Desktop, Claude Code, VS Code, Cursor, Kiro, LM Studio, and Google Gemini CLI
 - **Package Validation** — Ensure packages meet schema requirements before distribution
 - **Development-Focused** — Optimized for rapid development and testing of MCP server ecosystems
 
@@ -50,6 +50,7 @@ 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
 - **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.dev1.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=mDWKVA8Cg8lpXElkJbj8-7xyzI1AiJk3nlp2kOtpwPk,109150
 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=YZ9LEbR5E5p6padhPt114wvcsLCz16c2RPduhvvsj9I,1727
+hatch/mcp_host_config/backup.py,sha256=vl2YLL0P0bobGvx5moSAe4wI47vp25d-NpwNO95J3zU,16875
 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=OM5sKtQF-1hylXijNNRctKpHFQbPA88C3DorwyhGv20,25710
 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=WyelujfNtP0Y-KP5hS6u5Z9QSbMWcIxSv30nBQ1Ug7o,23998
+hatch_xclam-0.7.1.dev1.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
@@ -56,6 +56,15 @@ 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_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 +95,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.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,,

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.
+"""