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

tests/test_data_utils.py

@@ -292,6 +292,25 @@ class MCPHostConfigTestDataLoader(TestDataLoader):
         with open(config_path, 'r') as f:
             return json.load(f)
 
+    def load_kiro_mcp_config(self, config_type: str = "empty") -> Dict[str, Any]:
+        """Load Kiro-specific MCP configuration templates.
+        
+        Args:
+            config_type: Type of Kiro configuration to load
+                - "empty": Empty mcpServers configuration
+                - "with_server": Single server with all Kiro fields
+                - "complex": Multi-server with mixed configurations
+        
+        Returns:
+            Kiro MCP configuration dictionary
+        """
+        config_path = self.mcp_host_configs_dir / f"kiro_mcp_{config_type}.json"
+        if not config_path.exists():
+            self._create_kiro_mcp_config(config_type)
+
+        with open(config_path, 'r') as f:
+            return json.load(f)
+
     def _create_host_config_template(self, host_type: str, config_type: str):
         """Create host-specific configuration templates with inheritance patterns."""
         templates = {
@@ -364,6 +383,50 @@ class MCPHostConfigTestDataLoader(TestDataLoader):
                         "args": ["server.py"]
                     }
                 }
+            },
+
+            # Kiro family templates
+            "kiro_simple": {
+                "mcpServers": {
+                    "test_server": {
+                        "command": "auggie",
+                        "args": ["--mcp"],
+                        "disabled": False,
+                        "autoApprove": ["codebase-retrieval"]
+                    }
+                }
+            },
+            "kiro_with_server": {
+                "mcpServers": {
+                    "existing-server": {
+                        "command": "auggie",
+                        "args": ["--mcp", "-m", "default", "-w", "."],
+                        "env": {"DEBUG": "true"},
+                        "disabled": False,
+                        "autoApprove": ["codebase-retrieval", "fetch"],
+                        "disabledTools": ["dangerous-tool"]
+                    }
+                }
+            },
+            "kiro_complex": {
+                "mcpServers": {
+                    "local-server": {
+                        "command": "auggie",
+                        "args": ["--mcp"],
+                        "disabled": False,
+                        "autoApprove": ["codebase-retrieval"]
+                    },
+                    "remote-server": {
+                        "url": "https://api.example.com/mcp",
+                        "headers": {"Authorization": "Bearer token"},
+                        "disabled": True,
+                        "disabledTools": ["risky-tool"]
+                    }
+                },
+                "otherSettings": {
+                    "theme": "dark",
+                    "fontSize": 14
+                }
             }
         }
 
@@ -470,3 +533,48 @@ class MCPHostConfigTestDataLoader(TestDataLoader):
         config_path = self.mcp_host_configs_dir / f"mcp_server_{server_type}.json"
         with open(config_path, 'w') as f:
             json.dump(config, f, indent=2)
+
+    def _create_kiro_mcp_config(self, config_type: str):
+        """Create Kiro-specific MCP configuration templates."""
+        templates = {
+            "empty": {
+                "mcpServers": {}
+            },
+            "with_server": {
+                "mcpServers": {
+                    "existing-server": {
+                        "command": "auggie",
+                        "args": ["--mcp", "-m", "default", "-w", "."],
+                        "env": {"DEBUG": "true"},
+                        "disabled": False,
+                        "autoApprove": ["codebase-retrieval", "fetch"],
+                        "disabledTools": ["dangerous-tool"]
+                    }
+                }
+            },
+            "complex": {
+                "mcpServers": {
+                    "local-server": {
+                        "command": "auggie",
+                        "args": ["--mcp"],
+                        "disabled": False,
+                        "autoApprove": ["codebase-retrieval"]
+                    },
+                    "remote-server": {
+                        "url": "https://api.example.com/mcp",
+                        "headers": {"Authorization": "Bearer token"},
+                        "disabled": True,
+                        "disabledTools": ["risky-tool"]
+                    }
+                },
+                "otherSettings": {
+                    "theme": "dark",
+                    "fontSize": 14
+                }
+            }
+        }
+        
+        config = templates.get(config_type, {"mcpServers": {}})
+        config_path = self.mcp_host_configs_dir / f"kiro_mcp_{config_type}.json"
+        with open(config_path, 'w') as f:
+            json.dump(config, f, indent=2)

tests/test_mcp_cli_all_host_specific_args.py

@@ -15,7 +15,7 @@ from hatch.cli_hatch import handle_mcp_configure, parse_input
 from hatch.mcp_host_config import MCPHostType
 from hatch.mcp_host_config.models import (
     MCPServerConfigGemini, MCPServerConfigCursor, MCPServerConfigVSCode,
-    MCPServerConfigClaude
+    MCPServerConfigClaude, MCPServerConfigCodex
 )
 
 
@@ -298,6 +298,199 @@ class TestToolFilteringArguments(unittest.TestCase):
         self.assertEqual(server_config.excludeTools, ['dangerous_tool'])
 
 
+class TestAllCodexArguments(unittest.TestCase):
+    """Test ALL Codex-specific CLI arguments."""
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_all_codex_arguments_accepted(self, mock_stdout, mock_manager_class):
+        """Test that all Codex arguments are accepted and passed to model."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        # Test STDIO server with Codex-specific STDIO fields
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', '@upstash/context7-mcp'],
+            env_vars=['PATH', 'HOME'],
+            cwd='/workspace',
+            startup_timeout=15,
+            tool_timeout=120,
+            enabled=True,
+            include_tools=['read', 'write'],
+            exclude_tools=['delete'],
+            auto_approve=True
+        )
+
+        # Verify success
+        self.assertEqual(result, 0)
+
+        # Verify configure_server was called
+        mock_manager.configure_server.assert_called_once()
+
+        # Verify server_config is MCPServerConfigCodex
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertIsInstance(server_config, MCPServerConfigCodex)
+
+        # Verify Codex-specific STDIO fields
+        self.assertEqual(server_config.env_vars, ['PATH', 'HOME'])
+        self.assertEqual(server_config.cwd, '/workspace')
+        self.assertEqual(server_config.startup_timeout_sec, 15)
+        self.assertEqual(server_config.tool_timeout_sec, 120)
+        self.assertTrue(server_config.enabled)
+        self.assertEqual(server_config.enabled_tools, ['read', 'write'])
+        self.assertEqual(server_config.disabled_tools, ['delete'])
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_codex_env_vars_list(self, mock_stdout, mock_manager_class):
+        """Test that env_vars accepts multiple values as a list."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', 'package'],
+            env_vars=['PATH', 'HOME', 'USER'],
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertEqual(server_config.env_vars, ['PATH', 'HOME', 'USER'])
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_codex_env_header_parsing(self, mock_stdout, mock_manager_class):
+        """Test that env_header parses KEY=ENV_VAR format correctly."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', 'package'],
+            env_header=['X-API-Key=API_KEY', 'Authorization=AUTH_TOKEN'],
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertEqual(server_config.env_http_headers, {
+            'X-API-Key': 'API_KEY',
+            'Authorization': 'AUTH_TOKEN'
+        })
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_codex_timeout_fields(self, mock_stdout, mock_manager_class):
+        """Test that timeout fields are passed as integers."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', 'package'],
+            startup_timeout=30,
+            tool_timeout=180,
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertEqual(server_config.startup_timeout_sec, 30)
+        self.assertEqual(server_config.tool_timeout_sec, 180)
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_codex_enabled_flag(self, mock_stdout, mock_manager_class):
+        """Test that enabled flag works as boolean."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', 'package'],
+            enabled=True,
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertTrue(server_config.enabled)
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_codex_reuses_shared_arguments(self, mock_stdout, mock_manager_class):
+        """Test that Codex reuses shared arguments (cwd, include-tools, exclude-tools)."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', 'package'],
+            cwd='/workspace',
+            include_tools=['tool1', 'tool2'],
+            exclude_tools=['tool3'],
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+
+        # Verify shared arguments work for Codex STDIO servers
+        self.assertEqual(server_config.cwd, '/workspace')
+        self.assertEqual(server_config.enabled_tools, ['tool1', 'tool2'])
+        self.assertEqual(server_config.disabled_tools, ['tool3'])
+
+
 if __name__ == '__main__':
     unittest.main()
 

tests/test_mcp_cli_direct_management.py

@@ -40,17 +40,19 @@ class TestMCPConfigureCommand(unittest.TestCase):
                     try:
                         result = main()
                         # If main() returns without SystemExit, check the handler was called
-                        # Updated to include ALL host-specific parameters
+                        # Updated to include ALL host-specific parameters (27 total)
                         mock_handler.assert_called_once_with(
                             'claude-desktop', 'weather-server', 'python', ['weather.py'],
-                            None, None, None, None, False, None, None, None, None, None, None, False, False, False
+                            None, None, None, None, False, None, None, None, None, None, None,
+                            False, None, None, None, None, None, False, None, None, False, False, False
                         )
                     except SystemExit as e:
                         # If SystemExit is raised, it should be 0 (success) and handler should have been called
                         if e.code == 0:
                             mock_handler.assert_called_once_with(
                                 'claude-desktop', 'weather-server', 'python', ['weather.py'],
-                                None, None, None, None, False, None, None, None, None, None, None, False, False, False
+                                None, None, None, None, False, None, None, None, None, None, None,
+                                False, None, None, None, None, None, False, None, None, False, False, False
                             )
                         else:
                             self.fail(f"main() exited with code {e.code}, expected 0")
@@ -70,11 +72,12 @@ class TestMCPConfigureCommand(unittest.TestCase):
                 with patch('hatch.cli_hatch.handle_mcp_configure', return_value=0) as mock_handler:
                     try:
                         main()
-                        # Updated to include ALL host-specific parameters
+                        # Updated to include ALL host-specific parameters (27 total)
                         mock_handler.assert_called_once_with(
                             'cursor', 'file-server', None, None,
                             ['API_KEY=secret', 'DEBUG=true'], 'http://localhost:8080',
-                            ['Authorization=Bearer token'], None, False, None, None, None, None, None, None, True, True, True
+                            ['Authorization=Bearer token'], None, False, None, None, None, None, None, None,
+                            False, None, None, None, None, None, False, None, None, True, True, True
                         )
                     except SystemExit as e:
                         self.assertEqual(e.code, 0)