"""
Configuration Types and Defaults - Agent Orchestration Platform
Architecture Integration:
- Design Patterns: Configuration pattern with validation and defaults
- Security Model: Secure configuration with validation and sanitization
- Performance Profile: Efficient configuration loading with caching
Technical Decisions:
- Hierarchical Config: Server, session, and agent-level configuration
- Environment Integration: Environment variable support with validation
- Default Values: Comprehensive defaults for all configuration options
- Validation: Runtime validation with detailed error reporting
Dependencies & Integration:
- External: None (stdlib only for maximum portability)
- Internal: Foundation for all system configuration
Quality Assurance:
- Test Coverage: Property-based testing for all configuration operations
- Error Handling: Comprehensive validation with detailed diagnostics
Author: Adder_3 | Created: 2025-06-26 | Last Modified: 2025-06-26
"""
import os
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import Any, Dict, List, Optional, Set, Union
from .ids import SessionId
from .resources import ResourceLimits, create_default_resource_limits
from .security import SecurityLevel
# ============================================================================
# CONFIGURATION ENUMERATION - Configuration Categories and Types
# ============================================================================
class ConfigurationLevel(Enum):
"""Configuration hierarchy levels."""
SYSTEM = "system"
SERVER = "server"
SESSION = "session"
AGENT = "agent"
class ClaudeModel(Enum):
"""Supported Claude models."""
SONNET_3_5 = "sonnet-3.5"
OPUS_3 = "opus-3"
HAIKU_3 = "haiku-3"
SONNET_4 = "sonnet-4" # Future model
OPUS_4 = "opus-4" # Future model
class LogLevel(Enum):
"""Logging levels."""
DEBUG = "debug"
INFO = "info"
WARNING = "warning"
ERROR = "error"
CRITICAL = "critical"
class OutputFormat(Enum):
"""Claude Code output formats."""
TEXT = "text"
JSON = "json"
MARKDOWN = "markdown"
# ============================================================================
# CONFIGURATION EXCEPTIONS - Typed Error Handling
# ============================================================================
class ConfigurationError(Exception):
"""Base exception for configuration-related errors."""
def __init__(
self, message: str, config_path: str = None, error_code: str = "CONFIG_ERROR"
):
self.config_path = config_path
self.error_code = error_code
super().__init__(f"[{error_code}] {config_path or 'config'}: {message}")
class ConfigurationValidationError(ConfigurationError):
"""Exception for configuration validation failures."""
def __init__(self, message: str, config_path: str = None):
super().__init__(message, config_path, "CONFIG_VALIDATION_ERROR")
class EnvironmentConfigurationError(ConfigurationError):
"""Exception for environment variable configuration issues."""
def __init__(self, message: str, env_var: str = None):
super().__init__(message, env_var, "ENV_CONFIG_ERROR")
# ============================================================================
# CLAUDE CODE CONFIGURATION - Claude CLI Integration
# ============================================================================
@dataclass(frozen=True)
class ClaudeCodeConfig:
"""
Immutable Claude Code CLI configuration with comprehensive validation.
Architecture:
- Pattern: Immutable Configuration with validation
- Security: Secure CLI parameter validation and sanitization
- Performance: Efficient command generation with caching
- Integration: Complete Claude Code CLI integration
Contracts:
Preconditions:
- All paths are absolute and accessible
- Model name is supported by Claude Code CLI
- Resource limits are positive and realistic
Postconditions:
- Configuration is immutable after creation
- All parameters are validated and secure
- Command generation is deterministic
Invariants:
- Model compatibility with Claude Code CLI
- Working directory security and accessibility
- Environment variable safety and validation
Security Implementation:
- Path Validation: All paths validated for security
- Parameter Sanitization: CLI parameters sanitized
- Environment Security: Environment variables validated
- Command Injection Prevention: Safe command construction
"""
# Core Claude Code parameters
model: ClaudeModel = ClaudeModel.SONNET_3_5
no_color: bool = True
skip_permissions: bool = False
verbose: bool = False
output_format: OutputFormat = OutputFormat.TEXT
# Working directory and context
working_directory: Optional[Path] = None
context_files: List[Path] = field(default_factory=list)
# Environment and execution
environment_vars: Dict[str, str] = field(default_factory=dict)
timeout_seconds: int = 300
max_retries: int = 3
retry_delay_seconds: int = 5
# Resource limits
max_memory_mb: int = 512
max_cpu_percent: float = 25.0
max_output_size_mb: int = 10
# Advanced options
custom_system_prompt: str = ""
additional_args: List[str] = field(default_factory=list)
stdin_input: str = ""
def __post_init__(self):
"""Validate Claude Code configuration."""
# Timeout validation
if self.timeout_seconds <= 0 or self.timeout_seconds > 3600:
raise ConfigurationValidationError(
f"Timeout {self.timeout_seconds} must be in range (0, 3600]",
"timeout_seconds",
)
# Retry validation
if self.max_retries < 0 or self.max_retries > 10:
raise ConfigurationValidationError(
f"Max retries {self.max_retries} must be in range [0, 10]",
"max_retries",
)
if self.retry_delay_seconds < 0 or self.retry_delay_seconds > 60:
raise ConfigurationValidationError(
f"Retry delay {self.retry_delay_seconds} must be in range [0, 60]",
"retry_delay_seconds",
)
# Resource validation
if self.max_memory_mb <= 0 or self.max_memory_mb > 4096:
raise ConfigurationValidationError(
f"Memory limit {self.max_memory_mb} must be in range (0, 4096]",
"max_memory_mb",
)
if self.max_cpu_percent <= 0 or self.max_cpu_percent > 100:
raise ConfigurationValidationError(
f"CPU limit {self.max_cpu_percent} must be in range (0, 100]",
"max_cpu_percent",
)
if self.max_output_size_mb <= 0 or self.max_output_size_mb > 100:
raise ConfigurationValidationError(
f"Output size limit {self.max_output_size_mb} must be in range (0, 100]",
"max_output_size_mb",
)
# Path validation
if self.working_directory and not self.working_directory.is_absolute():
raise ConfigurationValidationError(
f"Working directory must be absolute: {self.working_directory}",
"working_directory",
)
for context_file in self.context_files:
if not context_file.is_absolute():
raise ConfigurationValidationError(
f"Context file must be absolute path: {context_file}",
"context_files",
)
# Environment variable validation
dangerous_vars = {"PATH", "LD_LIBRARY_PATH", "PYTHONPATH"}
for var_name in self.environment_vars:
if var_name in dangerous_vars:
raise ConfigurationValidationError(
f"Dangerous environment variable: {var_name}", "environment_vars"
)
# Command injection prevention
dangerous_patterns = ["|", "&", ";", "`", "$", "(", ")", "<", ">", '"', "'"]
for arg in self.additional_args:
if any(pattern in arg for pattern in dangerous_patterns):
raise ConfigurationValidationError(
f"Additional arg contains dangerous pattern: {arg}",
"additional_args",
)
# System prompt validation
if len(self.custom_system_prompt) > 10000:
raise ConfigurationValidationError(
"Custom system prompt too long (>10KB)", "custom_system_prompt"
)
# Stdin validation
if len(self.stdin_input) > 1000000: # 1MB limit
raise ConfigurationValidationError(
"Stdin input too large (>1MB)", "stdin_input"
)
def get_base_command(self) -> List[str]:
"""
Generate base Claude Code command with validated parameters.
Returns:
List[str]: Base command parts for execution
"""
cmd = ["claude"]
# Model selection
if self.model != ClaudeModel.SONNET_3_5:
cmd.extend(["--model", self.model.value])
# Basic flags
if self.no_color:
cmd.append("--no-color")
if self.skip_permissions:
cmd.append("--skip-permissions")
if self.verbose:
cmd.append("--verbose")
# Output format
if self.output_format != OutputFormat.TEXT:
cmd.extend(["--format", self.output_format.value])
# Additional validated arguments
cmd.extend(self.additional_args)
return cmd
def get_activation_command(self, session_root: Path) -> str:
"""
Generate complete activation command for session context.
Args:
session_root: Session root directory for activation
Returns:
str: Complete activation command
"""
working_dir = self.working_directory or session_root
cmd_parts = [f"cd {working_dir}"]
cmd_parts.append(" && ")
cmd_parts.extend(self.get_base_command())
return "".join(cmd_parts)
def get_environment(self) -> Dict[str, str]:
"""
Get complete environment variables for Claude Code execution.
Returns:
Dict[str, str]: Environment variables
"""
env = dict(os.environ) # Start with current environment
# Add resource limits as environment variables
env.update(
{
"CLAUDE_MAX_MEMORY_MB": str(self.max_memory_mb),
"CLAUDE_MAX_CPU_PERCENT": str(self.max_cpu_percent),
"CLAUDE_TIMEOUT_SECONDS": str(self.timeout_seconds),
}
)
# Add custom environment variables
env.update(self.environment_vars)
return env
def with_working_directory(self, working_dir: Path) -> "ClaudeCodeConfig":
"""
Create new configuration with updated working directory.
Args:
working_dir: New working directory
Returns:
ClaudeCodeConfig: New configuration with updated directory
"""
return ClaudeCodeConfig(
model=self.model,
no_color=self.no_color,
skip_permissions=self.skip_permissions,
verbose=self.verbose,
output_format=self.output_format,
working_directory=working_dir,
context_files=self.context_files,
environment_vars=self.environment_vars,
timeout_seconds=self.timeout_seconds,
max_retries=self.max_retries,
retry_delay_seconds=self.retry_delay_seconds,
max_memory_mb=self.max_memory_mb,
max_cpu_percent=self.max_cpu_percent,
max_output_size_mb=self.max_output_size_mb,
custom_system_prompt=self.custom_system_prompt,
additional_args=self.additional_args,
stdin_input=self.stdin_input,
)
# ============================================================================
# ITERM2 INTEGRATION CONFIGURATION - Terminal Management
# ============================================================================
@dataclass(frozen=True)
class ITermConfig:
"""
Immutable iTerm2 integration configuration with validation.
Contracts:
Invariants:
- All timing parameters are positive and realistic
- Window and tab settings are valid iTerm2 configurations
- Profile names exist in iTerm2 configuration
"""
# Connection and timing
connection_timeout_seconds: int = 30
command_timeout_seconds: int = 60
health_check_interval_seconds: int = 30
# Window and tab management
create_new_window: bool = False
window_title_prefix: str = "Claude Agent"
tab_title_format: str = "{agent_name}"
profile_name: str = "Default"
# Text injection and output
text_injection_delay_ms: int = 100
output_capture_timeout_seconds: int = 10
max_output_lines: int = 1000
# Session management
preserve_session_on_error: bool = True
auto_restart_on_crash: bool = True
max_restart_attempts: int = 3
# Advanced settings
use_tmux_integration: bool = False
enable_mouse_reporting: bool = True
enable_focus_reporting: bool = False
def __post_init__(self):
"""Validate iTerm2 configuration."""
# Timeout validation
if (
self.connection_timeout_seconds <= 0
or self.connection_timeout_seconds > 300
):
raise ConfigurationValidationError(
f"Connection timeout {self.connection_timeout_seconds} must be in range (0, 300]",
"connection_timeout_seconds",
)
if self.command_timeout_seconds <= 0 or self.command_timeout_seconds > 600:
raise ConfigurationValidationError(
f"Command timeout {self.command_timeout_seconds} must be in range (0, 600]",
"command_timeout_seconds",
)
if (
self.health_check_interval_seconds <= 0
or self.health_check_interval_seconds > 300
):
raise ConfigurationValidationError(
f"Health check interval {self.health_check_interval_seconds} must be in range (0, 300]",
"health_check_interval_seconds",
)
# Text injection validation
if self.text_injection_delay_ms < 0 or self.text_injection_delay_ms > 5000:
raise ConfigurationValidationError(
f"Text injection delay {self.text_injection_delay_ms} must be in range [0, 5000]",
"text_injection_delay_ms",
)
if (
self.output_capture_timeout_seconds <= 0
or self.output_capture_timeout_seconds > 60
):
raise ConfigurationValidationError(
f"Output capture timeout {self.output_capture_timeout_seconds} must be in range (0, 60]",
"output_capture_timeout_seconds",
)
if self.max_output_lines <= 0 or self.max_output_lines > 10000:
raise ConfigurationValidationError(
f"Max output lines {self.max_output_lines} must be in range (0, 10000]",
"max_output_lines",
)
# Restart validation
if self.max_restart_attempts < 0 or self.max_restart_attempts > 10:
raise ConfigurationValidationError(
f"Max restart attempts {self.max_restart_attempts} must be in range [0, 10]",
"max_restart_attempts",
)
# Title format validation
if len(self.window_title_prefix) > 100:
raise ConfigurationValidationError(
"Window title prefix too long", "window_title_prefix"
)
if len(self.tab_title_format) > 100:
raise ConfigurationValidationError(
"Tab title format too long", "tab_title_format"
)
# Profile name validation
if not self.profile_name or len(self.profile_name) > 50:
raise ConfigurationValidationError("Invalid profile name", "profile_name")
# ============================================================================
# SERVER CONFIGURATION - MCP Server Settings
# ============================================================================
@dataclass(frozen=True)
class ServerConfig:
"""
Immutable MCP server configuration with comprehensive validation.
Architecture:
- Pattern: Hierarchical Configuration with environment integration
- Security: Secure server configuration with validation
- Performance: Optimized server settings with resource management
- Integration: Complete MCP server and transport configuration
Contracts:
Preconditions:
- All network settings are valid and secure
- Resource limits are positive and realistic
- Logging configuration is complete and accessible
Postconditions:
- Server configuration is immutable and validated
- All settings are within safe operational ranges
- Security settings are properly configured
Invariants:
- Port numbers are valid and available
- Directory paths are accessible and secure
- Resource limits prevent system exhaustion
"""
# Server identification
server_name: str = "Agent Orchestration Platform"
server_version: str = "1.0.0"
server_description: str = "Claude Code Agent Orchestration via FastMCP"
# Network and transport
host: str = "127.0.0.1"
port: int = 8080
transport: str = "stdio" # "stdio", "streamable-http", "sse"
max_connections: int = 100
connection_timeout_seconds: int = 30
# Logging and monitoring
log_level: LogLevel = LogLevel.INFO
log_directory: Path = Path("logs")
enable_audit_logging: bool = True
max_log_file_size_mb: int = 100
max_log_files: int = 10
# Security settings
security_level: SecurityLevel = SecurityLevel.HIGH
enable_authentication: bool = True
enable_rate_limiting: bool = True
max_requests_per_minute: int = 60
# Resource management
max_sessions: int = 16
max_agents_per_session: int = 8
max_total_agents: int = 32
resource_limits: ResourceLimits = field(
default_factory=create_default_resource_limits
)
# Performance tuning
enable_caching: bool = True
cache_size_mb: int = 256
worker_threads: int = 4
request_queue_size: int = 1000
# Development and debugging
debug_mode: bool = False
enable_metrics: bool = True
metrics_port: int = 9090
enable_health_check: bool = True
def __post_init__(self):
"""Validate server configuration."""
# Network validation
if not (1 <= self.port <= 65535):
raise ConfigurationValidationError(
f"Port {self.port} must be in range [1, 65535]", "port"
)
if not (1 <= self.metrics_port <= 65535):
raise ConfigurationValidationError(
f"Metrics port {self.metrics_port} must be in range [1, 65535]",
"metrics_port",
)
if self.port == self.metrics_port:
raise ConfigurationValidationError(
"Server port and metrics port cannot be the same", "metrics_port"
)
# Connection validation
if self.max_connections <= 0 or self.max_connections > 10000:
raise ConfigurationValidationError(
f"Max connections {self.max_connections} must be in range (0, 10000]",
"max_connections",
)
if (
self.connection_timeout_seconds <= 0
or self.connection_timeout_seconds > 300
):
raise ConfigurationValidationError(
f"Connection timeout {self.connection_timeout_seconds} must be in range (0, 300]",
"connection_timeout_seconds",
)
# Transport validation
valid_transports = {"stdio", "streamable-http", "sse"}
if self.transport not in valid_transports:
raise ConfigurationValidationError(
f"Invalid transport {self.transport}, must be one of {valid_transports}",
"transport",
)
# Logging validation
if self.max_log_file_size_mb <= 0 or self.max_log_file_size_mb > 1000:
raise ConfigurationValidationError(
f"Max log file size {self.max_log_file_size_mb} must be in range (0, 1000]",
"max_log_file_size_mb",
)
if self.max_log_files <= 0 or self.max_log_files > 100:
raise ConfigurationValidationError(
f"Max log files {self.max_log_files} must be in range (0, 100]",
"max_log_files",
)
# Rate limiting validation
if self.max_requests_per_minute <= 0 or self.max_requests_per_minute > 10000:
raise ConfigurationValidationError(
f"Max requests per minute {self.max_requests_per_minute} must be in range (0, 10000]",
"max_requests_per_minute",
)
# Resource validation
if self.max_sessions <= 0 or self.max_sessions > 100:
raise ConfigurationValidationError(
f"Max sessions {self.max_sessions} must be in range (0, 100]",
"max_sessions",
)
if self.max_agents_per_session <= 0 or self.max_agents_per_session > 50:
raise ConfigurationValidationError(
f"Max agents per session {self.max_agents_per_session} must be in range (0, 50]",
"max_agents_per_session",
)
if self.max_total_agents <= 0 or self.max_total_agents > 500:
raise ConfigurationValidationError(
f"Max total agents {self.max_total_agents} must be in range (0, 500]",
"max_total_agents",
)
# Performance validation
if self.cache_size_mb <= 0 or self.cache_size_mb > 2048:
raise ConfigurationValidationError(
f"Cache size {self.cache_size_mb} must be in range (0, 2048]",
"cache_size_mb",
)
if self.worker_threads <= 0 or self.worker_threads > 32:
raise ConfigurationValidationError(
f"Worker threads {self.worker_threads} must be in range (0, 32]",
"worker_threads",
)
if self.request_queue_size <= 0 or self.request_queue_size > 10000:
raise ConfigurationValidationError(
f"Request queue size {self.request_queue_size} must be in range (0, 10000]",
"request_queue_size",
)
# String validation
if len(self.server_name) > 100:
raise ConfigurationValidationError("Server name too long", "server_name")
if len(self.server_description) > 500:
raise ConfigurationValidationError(
"Server description too long", "server_description"
)
def get_server_info(self) -> Dict[str, Any]:
"""
Get server information for MCP protocol.
Returns:
Dict[str, Any]: Server information
"""
return {
"name": self.server_name,
"version": self.server_version,
"description": self.server_description,
"transport": self.transport,
"host": self.host if self.transport != "stdio" else None,
"port": self.port if self.transport != "stdio" else None,
"security_level": self.security_level.value,
"max_sessions": self.max_sessions,
"max_agents_per_session": self.max_agents_per_session,
"debug_mode": self.debug_mode,
}
def is_network_transport(self) -> bool:
"""Check if server uses network transport."""
return self.transport in ["streamable-http", "sse"]
def requires_authentication(self) -> bool:
"""Check if server requires authentication."""
return self.enable_authentication and self.is_network_transport()
# ============================================================================
# SYSTEM CONFIGURATION - Complete System Settings
# ============================================================================
@dataclass(frozen=True)
class SystemConfig:
"""
Immutable complete system configuration combining all subsystems.
Architecture:
- Pattern: Composite Configuration with hierarchical validation
- Security: Complete security configuration across all components
- Performance: Optimized system-wide performance settings
- Integration: Unified configuration for entire agent orchestration platform
Contracts:
Preconditions:
- All subsystem configurations are valid
- Configuration consistency across components
- Environment compatibility and requirements met
Postconditions:
- System configuration is immutable and validated
- All subsystems have consistent settings
- Configuration can be safely applied to running system
Invariants:
- Resource allocation consistency across components
- Security settings alignment and compatibility
- Network configuration consistency and validity
"""
# Core subsystem configurations
server_config: ServerConfig = field(default_factory=ServerConfig)
claude_config: ClaudeCodeConfig = field(default_factory=ClaudeCodeConfig)
iterm_config: ITermConfig = field(default_factory=ITermConfig)
# Environment and deployment
environment: str = "development" # "development", "staging", "production"
data_directory: Path = Path("data")
temp_directory: Path = Path("tmp")
backup_directory: Path = Path("backups")
# Feature flags
enable_git_integration: bool = True
enable_task_file_monitoring: bool = True
enable_performance_monitoring: bool = True
enable_auto_recovery: bool = True
# System limits and quotas
max_disk_usage_gb: int = 10
max_session_duration_hours: int = 24
session_cleanup_interval_hours: int = 6
def __post_init__(self):
"""Validate complete system configuration."""
# Environment validation
valid_environments = {"development", "staging", "production"}
if self.environment not in valid_environments:
raise ConfigurationValidationError(
f"Invalid environment {self.environment}, must be one of {valid_environments}",
"environment",
)
# Directory validation
directories = [self.data_directory, self.temp_directory, self.backup_directory]
for directory in directories:
if not directory.is_absolute():
raise ConfigurationValidationError(
f"Directory must be absolute path: {directory}", str(directory)
)
# System limits validation
if self.max_disk_usage_gb <= 0 or self.max_disk_usage_gb > 1000:
raise ConfigurationValidationError(
f"Max disk usage {self.max_disk_usage_gb} must be in range (0, 1000]",
"max_disk_usage_gb",
)
if (
self.max_session_duration_hours <= 0
or self.max_session_duration_hours > 168
):
raise ConfigurationValidationError(
f"Max session duration {self.max_session_duration_hours} must be in range (0, 168]",
"max_session_duration_hours",
)
if (
self.session_cleanup_interval_hours <= 0
or self.session_cleanup_interval_hours > 24
):
raise ConfigurationValidationError(
f"Session cleanup interval {self.session_cleanup_interval_hours} must be in range (0, 24]",
"session_cleanup_interval_hours",
)
# Cross-component consistency validation
self._validate_resource_consistency()
self._validate_security_consistency()
self._validate_timeout_consistency()
def _validate_resource_consistency(self) -> None:
"""Validate resource allocation consistency across components."""
# Check that Claude config resource limits align with server limits
server_limits = self.server_config.resource_limits
claude_memory = self.claude_config.max_memory_mb
claude_cpu = self.claude_config.max_cpu_percent
if claude_memory > server_limits.memory_limit.hard_limit:
raise ConfigurationValidationError(
f"Claude memory limit {claude_memory} exceeds server limit {server_limits.memory_limit.hard_limit}",
"resource_consistency",
)
if claude_cpu > server_limits.cpu_limit.hard_limit:
raise ConfigurationValidationError(
f"Claude CPU limit {claude_cpu} exceeds server limit {server_limits.cpu_limit.hard_limit}",
"resource_consistency",
)
def _validate_security_consistency(self) -> None:
"""Validate security settings consistency across components."""
# Ensure security levels are consistent
server_security = self.server_config.security_level
# High security requires certain settings
if server_security == SecurityLevel.HIGH:
if not self.server_config.enable_authentication:
raise ConfigurationValidationError(
"High security level requires authentication",
"security_consistency",
)
if not self.server_config.enable_audit_logging:
raise ConfigurationValidationError(
"High security level requires audit logging", "security_consistency"
)
def _validate_timeout_consistency(self) -> None:
"""Validate timeout settings consistency across components."""
# Ensure timeouts are reasonable relative to each other
claude_timeout = self.claude_config.timeout_seconds
iterm_command_timeout = self.iterm_config.command_timeout_seconds
server_connection_timeout = self.server_config.connection_timeout_seconds
if claude_timeout < iterm_command_timeout:
raise ConfigurationValidationError(
f"Claude timeout {claude_timeout} should not be less than iTerm command timeout {iterm_command_timeout}",
"timeout_consistency",
)
def is_production(self) -> bool:
"""Check if system is in production environment."""
return self.environment == "production"
def is_development(self) -> bool:
"""Check if system is in development environment."""
return self.environment == "development"
def get_system_summary(self) -> Dict[str, Any]:
"""
Get comprehensive system configuration summary.
Returns:
Dict[str, Any]: System configuration summary
"""
return {
"environment": self.environment,
"server_name": self.server_config.server_name,
"server_version": self.server_config.server_version,
"transport": self.server_config.transport,
"security_level": self.server_config.security_level.value,
"max_sessions": self.server_config.max_sessions,
"max_agents_per_session": self.server_config.max_agents_per_session,
"claude_model": self.claude_config.model.value,
"data_directory": str(self.data_directory),
"git_integration": self.enable_git_integration,
"performance_monitoring": self.enable_performance_monitoring,
"debug_mode": self.server_config.debug_mode,
}
# ============================================================================
# CONFIGURATION FACTORY FUNCTIONS - Preset Configurations
# ============================================================================
def create_development_config() -> SystemConfig:
"""
Create development environment configuration.
Returns:
SystemConfig: Development configuration
"""
server_config = ServerConfig(
debug_mode=True,
log_level=LogLevel.DEBUG,
security_level=SecurityLevel.MEDIUM,
enable_authentication=False,
max_sessions=4,
max_agents_per_session=4,
)
claude_config = ClaudeCodeConfig(
verbose=True,
timeout_seconds=600, # Longer timeout for development
max_retries=1,
)
iterm_config = ITermConfig(
preserve_session_on_error=True, auto_restart_on_crash=True
)
return SystemConfig(
server_config=server_config,
claude_config=claude_config,
iterm_config=iterm_config,
environment="development",
enable_performance_monitoring=True,
)
def create_production_config() -> SystemConfig:
"""
Create production environment configuration.
Returns:
SystemConfig: Production configuration
"""
server_config = ServerConfig(
debug_mode=False,
log_level=LogLevel.INFO,
security_level=SecurityLevel.HIGH,
enable_authentication=True,
enable_rate_limiting=True,
max_sessions=16,
max_agents_per_session=8,
)
claude_config = ClaudeCodeConfig(verbose=False, timeout_seconds=300, max_retries=3)
iterm_config = ITermConfig(
preserve_session_on_error=False,
auto_restart_on_crash=True,
max_restart_attempts=2,
)
return SystemConfig(
server_config=server_config,
claude_config=claude_config,
iterm_config=iterm_config,
environment="production",
enable_auto_recovery=True,
)
def create_high_security_config() -> SystemConfig:
"""
Create high-security environment configuration.
Returns:
SystemConfig: High-security configuration
"""
from .resources import create_high_security_resource_limits
server_config = ServerConfig(
debug_mode=False,
log_level=LogLevel.WARNING,
security_level=SecurityLevel.MAXIMUM,
enable_authentication=True,
enable_rate_limiting=True,
max_requests_per_minute=30,
max_sessions=8,
max_agents_per_session=4,
resource_limits=create_high_security_resource_limits(),
)
claude_config = ClaudeCodeConfig(
skip_permissions=False,
timeout_seconds=180,
max_memory_mb=256,
max_cpu_percent=15.0,
max_retries=1,
)
iterm_config = ITermConfig(
preserve_session_on_error=False,
auto_restart_on_crash=False,
max_restart_attempts=1,
)
return SystemConfig(
server_config=server_config,
claude_config=claude_config,
iterm_config=iterm_config,
environment="production",
enable_auto_recovery=False,
max_session_duration_hours=8,
)
def load_config_from_environment() -> SystemConfig:
"""
Load configuration from environment variables with defaults.
Returns:
SystemConfig: Configuration loaded from environment
Raises:
EnvironmentConfigurationError: If environment configuration is invalid
"""
try:
# Server configuration from environment
server_config = ServerConfig(
host=os.getenv("MCP_HOST", "127.0.0.1"),
port=int(os.getenv("MCP_PORT", "8080")),
transport=os.getenv("MCP_TRANSPORT", "stdio"),
log_level=LogLevel(os.getenv("LOG_LEVEL", "info")),
debug_mode=os.getenv("DEBUG_MODE", "false").lower() == "true",
security_level=SecurityLevel(os.getenv("SECURITY_LEVEL", "high")),
max_sessions=int(os.getenv("MAX_SESSIONS", "16")),
max_agents_per_session=int(os.getenv("MAX_AGENTS_PER_SESSION", "8")),
)
# Claude configuration from environment
claude_config = ClaudeCodeConfig(
model=ClaudeModel(os.getenv("CLAUDE_MODEL", "sonnet-3.5")),
verbose=os.getenv("CLAUDE_VERBOSE", "false").lower() == "true",
timeout_seconds=int(os.getenv("CLAUDE_TIMEOUT", "300")),
max_memory_mb=int(os.getenv("CLAUDE_MAX_MEMORY_MB", "512")),
max_cpu_percent=float(os.getenv("CLAUDE_MAX_CPU_PERCENT", "25.0")),
)
# System configuration
return SystemConfig(
server_config=server_config,
claude_config=claude_config,
environment=os.getenv("ENVIRONMENT", "development"),
data_directory=Path(os.getenv("DATA_DIRECTORY", "data")),
enable_git_integration=os.getenv("ENABLE_GIT_INTEGRATION", "true").lower()
== "true",
enable_performance_monitoring=os.getenv(
"ENABLE_PERFORMANCE_MONITORING", "true"
).lower()
== "true",
)
except (ValueError, KeyError) as e:
raise EnvironmentConfigurationError(f"Invalid environment configuration: {e}")
