claude-expert-workflow-mcp
Version:
Production-ready MCP server for AI-powered product development consultation through specialized expert roles. Enterprise-grade with memory management, monitoring, and Claude Code integration.
368 lines • 15.7 kB
JavaScript
// System Configuration Manager
// Integrates configuration validation with all system components
import { configurationManager, createDefaultConfig } from './configurationValidator';
import { configurationEnforcer, ensureConfigurationCompliance } from '../utils/configurationEnforcer';
import { memoryManager } from '../utils/memoryManager';
import { gracefulDegradationManager } from '../utils/gracefulDegradation';
import { resourceLeakDetector } from '../utils/resourceLeakDetector';
import { correlationTracker } from '../utils/correlationTracker';
/**
* System Configuration Manager
* Central hub for all system configuration management
*/
export class SystemConfigurationManager {
constructor() {
this.configurationHistory = [];
}
static getInstance() {
if (!SystemConfigurationManager.instance) {
SystemConfigurationManager.instance = new SystemConfigurationManager();
}
return SystemConfigurationManager.instance;
}
/**
* Initialize system with default or provided configuration
*/
async initializeSystem(config, correlationId) {
const trackingCorrelationId = correlationId || correlationTracker.generateCorrelationId();
correlationTracker.startRequest('system-initialization', undefined, trackingCorrelationId, {
operation: 'initialize',
hasProvidedConfig: config !== undefined
});
try {
// Create full configuration from defaults and overrides
const defaultConfig = createDefaultConfig();
const fullConfig = config ? { ...defaultConfig, ...config } : defaultConfig;
// Apply configuration
const result = await this.updateSystemConfiguration(fullConfig, trackingCorrelationId);
correlationTracker.completeRequest(trackingCorrelationId, true);
return result;
}
catch (error) {
correlationTracker.completeRequest(trackingCorrelationId, false, error instanceof Error ? error.message : 'Unknown initialization error');
throw error;
}
}
/**
* Update system configuration with full validation and enforcement
*/
async updateSystemConfiguration(config, correlationId) {
const trackingCorrelationId = correlationId || correlationTracker.generateCorrelationId();
correlationTracker.startRequest('configuration-update', undefined, trackingCorrelationId, {
operation: 'update-system-config'
});
try {
// Validate configuration
const validationResult = await configurationManager.validateConfiguration(config, trackingCorrelationId);
let enforcementResult;
let success = validationResult.isValid;
// If validation passed, enforce configuration
if (validationResult.isValid && validationResult.config) {
const complianceResult = await ensureConfigurationCompliance(validationResult.config, trackingCorrelationId);
enforcementResult = {
enforced: complianceResult.enforced,
changes: complianceResult.issues.filter(i => i.type === 'enforcement').length,
warnings: complianceResult.issues.filter(i => i.severity === 'medium').length,
errors: complianceResult.issues.filter(i => i.severity === 'high').length
};
success = complianceResult.enforced;
if (complianceResult.enforced) {
// Start configuration enforcement if successful
configurationEnforcer.startEnforcement(validationResult.config, trackingCorrelationId);
}
}
// Generate system status
const systemStatus = await this.generateSystemStatus();
const result = {
success,
validationResult,
enforcementResult,
systemStatus
};
// Record configuration history
this.configurationHistory.push({
timestamp: Date.now(),
correlationId: trackingCorrelationId,
operation: 'update',
success,
config: validationResult.config
});
// Maintain history size
if (this.configurationHistory.length > 100) {
this.configurationHistory = this.configurationHistory.slice(-100);
}
correlationTracker.completeRequest(trackingCorrelationId, success);
return result;
}
catch (error) {
correlationTracker.completeRequest(trackingCorrelationId, false, error instanceof Error ? error.message : 'Unknown configuration error');
throw error;
}
}
/**
* Generate comprehensive system configuration status
*/
async generateSystemStatus() {
const issues = [];
// Get current configuration
const activeConfig = configurationManager.getCurrentConfig();
const runtimeState = configurationEnforcer.getRuntimeState();
// Check configuration compliance
const complianceCheck = configurationEnforcer.validateCompliance();
// Add compliance violations as issues
complianceCheck.violations.forEach(violation => {
issues.push({
type: 'enforcement',
severity: violation.severity,
component: violation.component,
message: violation.violation,
recommendation: violation.recommendation
});
});
// Check runtime system health
await this.checkRuntimeSystemHealth(issues);
// Determine component states
const componentStatus = {
memoryManager: this.getComponentStatus('memoryManager', runtimeState, issues),
resourceMonitor: this.getComponentStatus('resourceMonitor', runtimeState, issues),
degradationManager: this.getComponentStatus('degradationManager', runtimeState, issues),
correlationTracker: this.getComponentStatus('correlationTracker', runtimeState, issues)
};
const status = {
isValid: activeConfig !== undefined,
isEnforced: complianceCheck.compliant,
lastValidated: this.getLastOperationTime('validate'),
lastEnforced: runtimeState?.lastEnforced || 0,
activeConfig,
issues,
componentStatus
};
this.currentStatus = status;
return status;
}
/**
* Check runtime system health and add issues
*/
async checkRuntimeSystemHealth(issues) {
try {
// Check memory manager health
const memoryMetrics = memoryManager.getMemoryMetrics();
if (memoryMetrics.memoryPressure === 'critical') {
issues.push({
type: 'runtime',
severity: 'high',
component: 'memoryManager',
message: 'System under critical memory pressure',
recommendation: 'Perform immediate cleanup or restart system'
});
}
else if (memoryMetrics.memoryPressure === 'high') {
issues.push({
type: 'runtime',
severity: 'medium',
component: 'memoryManager',
message: 'System under high memory pressure',
recommendation: 'Monitor memory usage and consider cleanup'
});
}
// Check degradation manager health
const degradationStatus = gracefulDegradationManager.getSimplifiedStatus();
if (degradationStatus.level === 'critical') {
issues.push({
type: 'runtime',
severity: 'high',
component: 'degradationManager',
message: `System in critical degradation mode: ${degradationStatus.message}`,
recommendation: 'Investigate system resource constraints'
});
}
else if (degradationStatus.level !== 'normal') {
issues.push({
type: 'runtime',
severity: 'medium',
component: 'degradationManager',
message: `System in ${degradationStatus.level} degradation mode`,
recommendation: 'Monitor system resources'
});
}
// Check resource monitor health
const resourceReport = resourceLeakDetector.generateResourceReport();
if (resourceReport.status === 'critical') {
issues.push({
type: 'runtime',
severity: 'high',
component: 'resourceMonitor',
message: 'Resource leaks detected',
recommendation: 'Investigate memory and handle leaks'
});
}
else if (resourceReport.status === 'warning') {
issues.push({
type: 'runtime',
severity: 'medium',
component: 'resourceMonitor',
message: 'Resource usage warnings detected',
recommendation: 'Monitor resource consumption'
});
}
}
catch (error) {
issues.push({
type: 'runtime',
severity: 'high',
component: 'system',
message: `Failed to check system health: ${error instanceof Error ? error.message : 'Unknown error'}`,
recommendation: 'Check system component status manually'
});
}
}
/**
* Get component synchronization status
*/
getComponentStatus(component, runtimeState, issues) {
// Check for component errors in issues
const componentErrors = issues.filter(issue => issue.component === component && issue.severity === 'high');
if (componentErrors.length > 0) {
return 'error';
}
// Check enforcement state
if (runtimeState?.componentStates?.[component]) {
return runtimeState.componentStates[component];
}
// Check for component warnings
const componentWarnings = issues.filter(issue => issue.component === component && issue.severity === 'medium');
return componentWarnings.length > 0 ? 'drift' : 'synchronized';
}
/**
* Get last operation time from history
*/
getLastOperationTime(operation) {
const lastOp = this.configurationHistory
.filter(h => h.operation === operation)
.sort((a, b) => b.timestamp - a.timestamp)[0];
return lastOp?.timestamp || 0;
}
/**
* Get current system configuration status
*/
getCurrentStatus() {
return this.currentStatus ? { ...this.currentStatus } : undefined;
}
/**
* Get configuration operation history
*/
getConfigurationHistory(limit = 20) {
return this.configurationHistory
.slice(-limit)
.map(({ config, ...entry }) => entry);
}
/**
* Force configuration revalidation and enforcement
*/
async revalidateSystem(correlationId) {
const currentConfig = configurationManager.getCurrentConfig();
if (!currentConfig) {
throw new Error('No active configuration to revalidate');
}
return this.updateSystemConfiguration(currentConfig, correlationId);
}
/**
* Create configuration health report
*/
async generateHealthReport() {
const status = await this.generateSystemStatus();
// Determine overall health
const highSeverityIssues = status.issues.filter(i => i.severity === 'high');
const mediumSeverityIssues = status.issues.filter(i => i.severity === 'medium');
let overall;
if (highSeverityIssues.length > 0) {
overall = 'critical';
}
else if (mediumSeverityIssues.length > 0 || !status.isEnforced) {
overall = 'degraded';
}
else {
overall = 'healthy';
}
// Generate summary
let summary;
switch (overall) {
case 'healthy':
summary = 'All system components are properly configured and operating normally';
break;
case 'degraded':
summary = `System operational with ${mediumSeverityIssues.length} warnings requiring attention`;
break;
case 'critical':
summary = `System has ${highSeverityIssues.length} critical issues requiring immediate attention`;
break;
}
// Collect recommendations
const recommendations = [
...status.issues.map(i => i.recommendation).filter((rec) => rec !== undefined),
...(overall === 'critical' ? ['Consider system restart if issues persist'] : []),
...(overall === 'degraded' ? ['Schedule maintenance window to resolve warnings'] : [])
].filter((rec, index, arr) => arr.indexOf(rec) === index); // Remove duplicates
return {
overall,
summary,
details: {
configuration: status.isValid ? 'valid' : 'invalid',
enforcement: status.isEnforced ? 'compliant' : (highSeverityIssues.some(i => i.type === 'enforcement') ? 'error' : 'drift'),
runtime: highSeverityIssues.some(i => i.type === 'runtime') ? 'critical' :
mediumSeverityIssues.some(i => i.type === 'runtime') ? 'warning' : 'healthy'
},
recommendations,
lastChecked: Date.now()
};
}
/**
* Clear configuration history (for testing)
*/
clearHistory() {
this.configurationHistory = [];
this.currentStatus = undefined;
}
}
// Singleton instance for easy access
export const systemConfigurationManager = SystemConfigurationManager.getInstance();
/**
* Helper function to initialize system with environment-based configuration
*/
export async function initializeSystemFromEnvironment(correlationId) {
const envConfig = {};
// Load configuration from environment variables
if (process.env.MAX_MEMORY_MB) {
envConfig.memory = {
...createDefaultConfig().memory,
maxTotalMemoryMB: parseInt(process.env.MAX_MEMORY_MB, 10)
};
}
if (process.env.MAX_CONVERSATIONS) {
envConfig.memory = {
...envConfig.memory,
...createDefaultConfig().memory,
maxConversations: parseInt(process.env.MAX_CONVERSATIONS, 10)
};
}
if (process.env.DEBUG === 'true') {
envConfig.environment = {
...createDefaultConfig().environment,
debug: true,
logLevel: 'debug'
};
}
return systemConfigurationManager.initializeSystem(envConfig, correlationId);
}
/**
* Helper function for quick system health check
*/
export async function quickHealthCheck() {
const status = await systemConfigurationManager.generateSystemStatus();
return {
healthy: status.isValid && status.isEnforced && !status.issues.some(i => i.severity === 'high'),
issues: status.issues.length,
criticalIssues: status.issues.filter(i => i.severity === 'high').length
};
}
//# sourceMappingURL=systemConfigurationManager.js.map