mcp-proxy-adapter 6.2.23__py3-none-any.whl → 6.2.25__py3-none-any.whl

mcp_proxy_adapter/api/app.py

@@ -350,9 +350,6 @@ def create_app(title: Optional[str] = None, description: Optional[str] = None, v
     )
     
     # Setup middleware using the new middleware package
-    print(f"DEBUG create_app: calling setup_middleware with config type: {type(current_config)}")
-    if hasattr(current_config, 'keys'):
-        print(f"DEBUG create_app: current_config keys: {list(current_config.keys())}")
     setup_middleware(app, current_config)
     
     # Use custom OpenAPI schema

mcp_proxy_adapter/api/middleware/protocol_middleware.py

@@ -87,7 +87,7 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         Returns:
             Response object
         """
-        logger.info(f"ProtocolMiddleware.dispatch called for {request.method} {request.url.path}")
+        logger.debug(f"ProtocolMiddleware.dispatch called for {request.method} {request.url.path}")
         try:
             # Get protocol from request
             protocol = self._get_request_protocol(request)
@@ -169,32 +169,32 @@ def setup_protocol_middleware(app, app_config: Optional[Dict[str, Any]] = None):
         app: FastAPI application
         app_config: Application configuration dictionary (optional)
     """
-    logger.info(f"setup_protocol_middleware - app_config type: {type(app_config)}")
+    logger.debug(f"setup_protocol_middleware - app_config type: {type(app_config)}")
 
     # Check if protocol management is enabled
     if app_config is None:
         from mcp_proxy_adapter.config import config
         app_config = config.get_all()
-        logger.info(f"setup_protocol_middleware - loaded from global config, type: {type(app_config)}")
+        logger.debug(f"setup_protocol_middleware - loaded from global config, type: {type(app_config)}")
 
-    logger.info(f"setup_protocol_middleware - final app_config type: {type(app_config)}")
+    logger.debug(f"setup_protocol_middleware - final app_config type: {type(app_config)}")
 
     if hasattr(app_config, 'get'):
-        logger.info(f"setup_protocol_middleware - app_config keys: {list(app_config.keys()) if hasattr(app_config, 'keys') else 'no keys'}")
+        logger.debug(f"setup_protocol_middleware - app_config keys: {list(app_config.keys()) if hasattr(app_config, 'keys') else 'no keys'}")
         protocols_config = app_config.get("protocols", {})
-        logger.info(f"setup_protocol_middleware - protocols_config type: {type(protocols_config)}")
+        logger.debug(f"setup_protocol_middleware - protocols_config type: {type(protocols_config)}")
         enabled = protocols_config.get("enabled", True) if hasattr(protocols_config, 'get') else True
     else:
-        logger.info(f"setup_protocol_middleware - app_config is not dict-like: {repr(app_config)}")
+        logger.debug(f"setup_protocol_middleware - app_config is not dict-like: {repr(app_config)}")
         enabled = True
 
-    logger.info(f"setup_protocol_middleware - protocol management enabled: {enabled}")
+    logger.debug(f"setup_protocol_middleware - protocol management enabled: {enabled}")
 
     if enabled:
         # Create protocol middleware with current configuration
-        logger.info(f"setup_protocol_middleware - creating ProtocolMiddleware with config type: {type(app_config)}")
+        logger.debug(f"setup_protocol_middleware - creating ProtocolMiddleware with config type: {type(app_config)}")
         middleware = ProtocolMiddleware(app, app_config)
-        logger.info(f"setup_protocol_middleware - adding middleware to app")
+        logger.debug(f"setup_protocol_middleware - adding middleware to app")
         app.add_middleware(ProtocolMiddleware, app_config=app_config)
         logger.info("Protocol middleware added to application")
     else:

mcp_proxy_adapter/commands/health_command.py

@@ -80,7 +80,7 @@ class HealthCommand(Command):
     name = "health"
     result_class = HealthResult
     
-    async def execute(self) -> HealthResult:
+    async def execute(self, **kwargs) -> HealthResult:
         """
         Execute health command.
         

mcp_proxy_adapter/config.py

@@ -118,18 +118,24 @@ class Config:
                 "auto_register_on_startup": True,
                 "auto_unregister_on_shutdown": True
             },
+            "commands": {
+                "auto_discovery": True,
+                "enabled_commands": ["health", "echo", "list", "help"],
+                "disabled_commands": [],
+                "custom_commands_path": "./commands"
+            },
             "debug": {
                 "enabled": False,
                 "level": "WARNING"
             },
             "security": {
                 "framework": "mcp_security_framework",
-                "enabled": True,
+                "enabled": False,
                 "debug": False,
                 "environment": "dev",
                 "version": "1.0.0",
                 "auth": {
-                    "enabled": True,
+                    "enabled": False,
                     "methods": ["api_key"],
                     "api_keys": {},
                     "user_roles": {},
@@ -175,7 +181,7 @@ class Config:
                     "renewal_threshold_days": 30
                 },
                 "permissions": {
-                    "enabled": True,
+                    "enabled": False,
                     "roles_file": None,
                     "default_role": "guest",
                     "admin_role": "admin",
@@ -187,7 +193,7 @@ class Config:
                     "roles": None
                 },
                 "rate_limit": {
-                    "enabled": True,
+                    "enabled": False,
                     "default_requests_per_minute": 60,
                     "default_requests_per_hour": 1000,
                     "burst_limit": 2,
@@ -212,6 +218,12 @@ class Config:
                     "include_level": True,
                     "include_module": True
                 }
+            },
+            "protocols": {
+                "enabled": True,
+                "allowed_protocols": ["http", "jsonrpc"],
+                "default_protocol": "http",
+                "auto_discovery": True
             }
         }
         

mcp_proxy_adapter/core/protocol_manager.py

@@ -35,28 +35,28 @@ class ProtocolManager:
         """Load protocol configuration from config."""
         # Use provided config or fallback to global config; normalize types
         current_config = self.app_config if self.app_config is not None else config.get_all()
-        logger.info(f"ProtocolManager._load_config - current_config type: {type(current_config)}")
+        logger.debug(f"ProtocolManager._load_config - current_config type: {type(current_config)}")
 
         if not hasattr(current_config, 'get'):
             # Not a dict-like config, fallback to global
-            logger.info(f"ProtocolManager._load_config - current_config is not dict-like, falling back to global config")
+            logger.debug(f"ProtocolManager._load_config - current_config is not dict-like, falling back to global config")
             current_config = config.get_all()
 
-        logger.info(f"ProtocolManager._load_config - final current_config type: {type(current_config)}")
+        logger.debug(f"ProtocolManager._load_config - final current_config type: {type(current_config)}")
         if hasattr(current_config, 'get'):
-            logger.info(f"ProtocolManager._load_config - current_config keys: {list(current_config.keys()) if hasattr(current_config, 'keys') else 'no keys'}")
+            logger.debug(f"ProtocolManager._load_config - current_config keys: {list(current_config.keys()) if hasattr(current_config, 'keys') else 'no keys'}")
 
         # Get protocols configuration
-        logger.info(f"ProtocolManager._load_config - before getting protocols")
+        logger.debug(f"ProtocolManager._load_config - before getting protocols")
         try:
             self.protocols_config = current_config.get("protocols", {})
-            logger.info(f"ProtocolManager._load_config - protocols_config type: {type(self.protocols_config)}")
+            logger.debug(f"ProtocolManager._load_config - protocols_config type: {type(self.protocols_config)}")
             if hasattr(self.protocols_config, 'get'):
-                logger.info(f"ProtocolManager._load_config - protocols_config is dict-like")
+                logger.debug(f"ProtocolManager._load_config - protocols_config is dict-like")
             else:
-                logger.info(f"ProtocolManager._load_config - protocols_config is NOT dict-like: {repr(self.protocols_config)}")
+                logger.debug(f"ProtocolManager._load_config - protocols_config is NOT dict-like: {repr(self.protocols_config)}")
         except Exception as e:
-            logger.info(f"ProtocolManager._load_config - ERROR getting protocols: {e}")
+            logger.debug(f"ProtocolManager._load_config - ERROR getting protocols: {e}")
             self.protocols_config = {}
 
         self.enabled = self.protocols_config.get("enabled", True) if hasattr(self.protocols_config, 'get') else True

mcp_proxy_adapter/examples/create_certificates_simple.py

@@ -466,18 +466,13 @@ class SimpleCertificateCreator:
                     shutil.copy2(ca_cert, expected_ca_cert)
                     print(f"✅ Created CA certificate copy: {expected_ca_cert}")
 
-            # Server certificate symlink
+            # Server certificate copy
             server_cert = self.certs_dir / "server_cert.pem"
             expected_server_cert = self.certs_dir / "localhost_server.crt"
             if server_cert.exists() and not expected_server_cert.exists():
-                try:
-                    expected_server_cert.symlink_to(server_cert)
-                    print(f"✅ Created server certificate symlink: {expected_server_cert}")
-                except OSError:
-                    # On Windows, symlink might require admin privileges, copy instead
-                    import shutil
-                    shutil.copy2(server_cert, expected_server_cert)
-                    print(f"✅ Created server certificate copy: {expected_server_cert}")
+                import shutil
+                shutil.copy2(server_cert, expected_server_cert)
+                print(f"✅ Created server certificate copy: {expected_server_cert}")
 
             # Server key symlink - check if it's in certs or keys directory
             server_key_certs = self.certs_dir / "server_key.pem"
@@ -492,14 +487,9 @@ class SimpleCertificateCreator:
             if server_key_keys.exists():
                 expected_server_key = self.keys_dir / "localhost_server.key"
                 if not expected_server_key.exists():
-                    try:
-                        expected_server_key.symlink_to(server_key_keys)
-                        print(f"✅ Created server key symlink: {expected_server_key}")
-                    except OSError:
-                        # On Windows, symlink might require admin privileges, copy instead
-                        import shutil
-                        shutil.copy2(server_key_keys, expected_server_key)
-                        print(f"✅ Created server key copy: {expected_server_key}")
+                    import shutil
+                    shutil.copy2(server_key_keys, expected_server_key)
+                    print(f"✅ Created server key copy: {expected_server_key}")
 
         # Print summary
         print("\n" + "=" * 60)

mcp_proxy_adapter/examples/examples/basic_framework/__init__.py

@@ -0,0 +1,9 @@
+"""Basic Framework Example.
+
+This example demonstrates the fundamental usage of MCP Proxy Adapter
+with minimal configuration and basic command registration.
+
+Note: This package provides a basic example of MCP Proxy Adapter usage.
+The main application is created dynamically in main.py and not exported
+as a global variable for this example.
+"""

mcp_proxy_adapter/examples/examples/basic_framework/commands/__init__.py

@@ -0,0 +1,4 @@
+"""Basic Framework Commands.
+
+Commands for the basic framework example.
+"""

mcp_proxy_adapter/examples/examples/basic_framework/hooks/__init__.py

@@ -0,0 +1,4 @@
+"""Basic Framework Hooks.
+
+Hooks for the basic framework example.
+"""

mcp_proxy_adapter/examples/examples/basic_framework/main.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""
+Basic Framework Example
+This example demonstrates the basic usage of the MCP Proxy Adapter framework
+with minimal configuration and built-in commands.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import sys
+import argparse
+from pathlib import Path
+# Add the framework to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+from mcp_proxy_adapter.core.app_factory import create_and_run_server
+def main():
+    """Main entry point for the basic framework example."""
+    parser = argparse.ArgumentParser(description="Basic Framework Example")
+    parser.add_argument("--config", "-c", required=True, help="Path to configuration file")
+    parser.add_argument("--host", help="Server host")
+    parser.add_argument("--port", type=int, help="Server port")
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
+    args = parser.parse_args()
+    # Override configuration if specified
+    config_overrides = {}
+    if args.host:
+        config_overrides["host"] = args.host
+    if args.port:
+        config_overrides["port"] = args.port
+    if args.debug:
+        config_overrides["debug"] = True
+    print(f"🚀 Starting Basic Framework Example")
+    print(f"📋 Configuration: {args.config}")
+    print("=" * 50)
+    # Use the factory method to create and run the server
+    create_and_run_server(
+        config_path=args.config,
+        title="Basic Framework Example",
+        description="Basic MCP Proxy Adapter with minimal configuration",
+        version="1.0.0",
+        host=config_overrides.get("host", "0.0.0.0"),
+        log_level="debug" if config_overrides.get("debug", False) else "info"
+    )
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter/examples/examples/full_application/__init__.py

@@ -0,0 +1,12 @@
+"""Full Application Example.
+
+This example demonstrates advanced usage of MCP Proxy Adapter including:
+- Proxy registration endpoints
+- Custom command hooks
+- Advanced security configurations
+- Role-based access control
+"""
+
+from .main import get_app
+app = get_app()
+from .proxy_endpoints import router as proxy_router

mcp_proxy_adapter/examples/examples/full_application/commands/__init__.py

@@ -0,0 +1,7 @@
+"""Full Application Commands.
+
+Custom command implementations for the full application example.
+"""
+
+from .custom_echo_command import CustomEchoCommand
+from .dynamic_calculator_command import DynamicCalculatorCommand

mcp_proxy_adapter/examples/examples/full_application/commands/custom_echo_command.py

@@ -0,0 +1,80 @@
+"""
+Custom Echo Command
+This module demonstrates a custom command implementation for the full application example.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+from typing import Dict, Any, Optional
+from mcp_proxy_adapter.commands.base import BaseCommand
+from mcp_proxy_adapter.commands.result import CommandResult
+class CustomEchoResult(CommandResult):
+    """Result class for custom echo command."""
+    def __init__(self, message: str, timestamp: str, echo_count: int):
+        self.message = message
+        self.timestamp = timestamp
+        self.echo_count = echo_count
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary."""
+        return {
+            "message": self.message,
+            "timestamp": self.timestamp,
+            "echo_count": self.echo_count,
+            "command_type": "custom_echo"
+        }
+    def get_schema(self) -> Dict[str, Any]:
+        """Get result schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string", "description": "Echoed message"},
+                "timestamp": {"type": "string", "description": "Timestamp of echo"},
+                "echo_count": {"type": "integer", "description": "Number of echoes"},
+                "command_type": {"type": "string", "description": "Command type"}
+            },
+            "required": ["message", "timestamp", "echo_count", "command_type"]
+        }
+class CustomEchoCommand(BaseCommand):
+    """Custom echo command implementation."""
+    def __init__(self):
+        super().__init__()
+        self.echo_count = 0
+    def get_name(self) -> str:
+        """Get command name."""
+        return "custom_echo"
+    def get_description(self) -> str:
+        """Get command description."""
+        return "Custom echo command with enhanced features"
+    def get_schema(self) -> Dict[str, Any]:
+        """Get command schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "Message to echo",
+                    "default": "Hello from custom echo!"
+                },
+                "repeat": {
+                    "type": "integer",
+                    "description": "Number of times to repeat",
+                    "default": 1,
+                    "minimum": 1,
+                    "maximum": 10
+                }
+            },
+            "required": ["message"]
+        }
+    async def execute(self, params: Dict[str, Any]) -> CustomEchoResult:
+        """Execute the custom echo command."""
+        message = params.get("message", "Hello from custom echo!")
+        repeat = min(max(params.get("repeat", 1), 1), 10)
+        self.echo_count += 1
+        from datetime import datetime
+        timestamp = datetime.now().isoformat()
+        # Repeat the message
+        echoed_message = " ".join([message] * repeat)
+        return CustomEchoResult(
+            message=echoed_message,
+            timestamp=timestamp,
+            echo_count=self.echo_count
+        )

mcp_proxy_adapter/examples/examples/full_application/commands/dynamic_calculator_command.py

@@ -0,0 +1,90 @@
+"""
+Dynamic Calculator Command
+This module demonstrates a dynamically loaded command implementation for the full application example.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+from typing import Dict, Any, Optional
+from mcp_proxy_adapter.commands.base import BaseCommand
+from mcp_proxy_adapter.commands.result import CommandResult
+class CalculatorResult(CommandResult):
+    """Result class for calculator command."""
+    def __init__(self, operation: str, result: float, expression: str):
+        self.operation = operation
+        self.result = result
+        self.expression = expression
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert result to dictionary."""
+        return {
+            "operation": self.operation,
+            "result": self.result,
+            "expression": self.expression,
+            "command_type": "dynamic_calculator"
+        }
+    def get_schema(self) -> Dict[str, Any]:
+        """Get result schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "operation": {"type": "string", "description": "Mathematical operation"},
+                "result": {"type": "number", "description": "Calculation result"},
+                "expression": {"type": "string", "description": "Full expression"},
+                "command_type": {"type": "string", "description": "Command type"}
+            },
+            "required": ["operation", "result", "expression", "command_type"]
+        }
+class DynamicCalculatorCommand(BaseCommand):
+    """Dynamic calculator command implementation."""
+    def get_name(self) -> str:
+        """Get command name."""
+        return "dynamic_calculator"
+    def get_description(self) -> str:
+        """Get command description."""
+        return "Dynamic calculator with basic mathematical operations"
+    def get_schema(self) -> Dict[str, Any]:
+        """Get command schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "operation": {
+                    "type": "string",
+                    "description": "Mathematical operation (add, subtract, multiply, divide)",
+                    "enum": ["add", "subtract", "multiply", "divide"]
+                },
+                "a": {
+                    "type": "number",
+                    "description": "First number"
+                },
+                "b": {
+                    "type": "number",
+                    "description": "Second number"
+                }
+            },
+            "required": ["operation", "a", "b"]
+        }
+    async def execute(self, params: Dict[str, Any]) -> CalculatorResult:
+        """Execute the calculator command."""
+        operation = params.get("operation")
+        a = params.get("a")
+        b = params.get("b")
+        if operation == "add":
+            result = a + b
+            expression = f"{a} + {b}"
+        elif operation == "subtract":
+            result = a - b
+            expression = f"{a} - {b}"
+        elif operation == "multiply":
+            result = a * b
+            expression = f"{a} * {b}"
+        elif operation == "divide":
+            if b == 0:
+                raise ValueError("Division by zero is not allowed")
+            result = a / b
+            expression = f"{a} / {b}"
+        else:
+            raise ValueError(f"Unknown operation: {operation}")
+        return CalculatorResult(
+            operation=operation,
+            result=result,
+            expression=expression
+        )

mcp_proxy_adapter/examples/examples/full_application/hooks/__init__.py

@@ -0,0 +1,7 @@
+"""Full Application Hooks.
+
+Application and command hooks for the full application example.
+"""
+
+from .application_hooks import ApplicationHooks
+from .builtin_command_hooks import BuiltinCommandHooks

mcp_proxy_adapter/examples/examples/full_application/hooks/application_hooks.py

@@ -0,0 +1,75 @@
+"""
+Application Hooks
+This module demonstrates application-level hooks in the full application example.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import logging
+from typing import Dict, Any, Optional
+from datetime import datetime
+logger = logging.getLogger(__name__)
+class ApplicationHooks:
+    """Application-level hooks."""
+    @staticmethod
+    def on_startup():
+        """Hook executed on application startup."""
+        logger.info("🚀 Application startup hook executed")
+        # Initialize application-specific resources
+        logger.info("📊 Initializing application metrics")
+        logger.info("🔐 Loading security configurations")
+        logger.info("📝 Setting up logging")
+    @staticmethod
+    def on_shutdown():
+        """Hook executed on application shutdown."""
+        logger.info("🛑 Application shutdown hook executed")
+        # Cleanup application resources
+        logger.info("🧹 Cleaning up resources")
+        logger.info("💾 Saving application state")
+        logger.info("📊 Finalizing metrics")
+    @staticmethod
+    def before_request(request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed before processing any request."""
+        logger.info(f"🔧 Application hook: before_request with data: {request_data}")
+        # Add request metadata
+        request_data["app_metadata"] = {
+            "request_id": f"req_{datetime.now().timestamp()}",
+            "timestamp": datetime.now().isoformat(),
+            "application": "full_application_example"
+        }
+        return request_data
+    @staticmethod
+    def after_request(result: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed after processing any request."""
+        logger.info(f"🔧 Application hook: after_request with result: {result}")
+        # Add response metadata
+        result["app_response_metadata"] = {
+            "processed_at": datetime.now().isoformat(),
+            "application": "full_application_example",
+            "version": "1.0.0"
+        }
+        return result
+    @staticmethod
+    def on_error(error: Exception, context: Dict[str, Any]):
+        """Hook executed when an error occurs."""
+        logger.error(f"🔧 Application hook: on_error - {error} in context: {context}")
+        # Log error details
+        logger.error(f"Error type: {type(error).__name__}")
+        logger.error(f"Error message: {str(error)}")
+        logger.error(f"Context: {context}")
+    @staticmethod
+    def on_command_registered(command_name: str, command_info: Dict[str, Any]):
+        """Hook executed when a command is registered."""
+        logger.info(f"🔧 Application hook: on_command_registered - {command_name}")
+        logger.info(f"Command info: {command_info}")
+        # Track registered commands
+        logger.info(f"📝 Command '{command_name}' registered successfully")
+    @staticmethod
+    def on_command_executed(command_name: str, execution_time: float, success: bool):
+        """Hook executed when a command is executed."""
+        logger.info(f"🔧 Application hook: on_command_executed - {command_name}")
+        logger.info(f"Execution time: {execution_time}s, Success: {success}")
+        # Track command execution metrics
+        if success:
+            logger.info(f"✅ Command '{command_name}' executed successfully in {execution_time}s")
+        else:
+            logger.warning(f"⚠️ Command '{command_name}' failed after {execution_time}s")

mcp_proxy_adapter/examples/examples/full_application/hooks/builtin_command_hooks.py

@@ -0,0 +1,71 @@
+"""
+Built-in Command Hooks
+This module demonstrates hooks for built-in commands in the full application example.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import logging
+from typing import Dict, Any, Optional
+from datetime import datetime
+logger = logging.getLogger(__name__)
+class BuiltinCommandHooks:
+    """Hooks for built-in commands."""
+    @staticmethod
+    def before_echo_command(params: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed before echo command."""
+        logger.info(f"🔧 Built-in hook: before_echo_command with params: {params}")
+        # Add timestamp to message
+        if "message" in params:
+            timestamp = datetime.now().isoformat()
+            params["message"] = f"[{timestamp}] {params['message']}"
+        return params
+    @staticmethod
+    def after_echo_command(result: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed after echo command."""
+        logger.info(f"🔧 Built-in hook: after_echo_command with result: {result}")
+        # Add hook metadata
+        result["hook_metadata"] = {
+            "hook_type": "builtin_after_echo",
+            "timestamp": datetime.now().isoformat(),
+            "processed": True
+        }
+        return result
+    @staticmethod
+    def before_health_command(params: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed before health command."""
+        logger.info(f"🔧 Built-in hook: before_health_command with params: {params}")
+        # Add custom health check parameters
+        params["include_detailed_info"] = True
+        params["check_dependencies"] = True
+        return params
+    @staticmethod
+    def after_health_command(result: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed after health command."""
+        logger.info(f"🔧 Built-in hook: after_health_command with result: {result}")
+        # Add custom health metrics
+        if "status" in result and result["status"] == "healthy":
+            result["custom_metrics"] = {
+                "uptime": "24h",
+                "memory_usage": "45%",
+                "cpu_usage": "12%"
+            }
+        return result
+    @staticmethod
+    def before_config_command(params: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed before config command."""
+        logger.info(f"🔧 Built-in hook: before_config_command with params: {params}")
+        # Add configuration validation
+        params["validate_config"] = True
+        params["include_secrets"] = False
+        return params
+    @staticmethod
+    def after_config_command(result: Dict[str, Any]) -> Dict[str, Any]:
+        """Hook executed after config command."""
+        logger.info(f"🔧 Built-in hook: after_config_command with result: {result}")
+        # Add configuration metadata
+        result["config_metadata"] = {
+            "last_modified": datetime.now().isoformat(),
+            "version": "1.0.0",
+            "environment": "development"
+        }
+        return result