claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/swarm/error-recovery/resilience-architecture.js

@@ -0,0 +1,714 @@
+/**
+ * Resilience Architecture
+ * Circuit breaker patterns, failover mechanisms, and disaster recovery procedures
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { EventEmitter } from "node:events";
+import { createClient } from "redis";
+export var CircuitState = /*#__PURE__*/ function(CircuitState) {
+    CircuitState["CLOSED"] = "closed";
+    CircuitState["OPEN"] = "open";
+    CircuitState["HALF_OPEN"] = "half_open"; // Testing if service has recovered
+    return CircuitState;
+}({});
+export class ResilienceArchitecture extends EventEmitter {
+    async start() {
+        if (this.isRunning) {
+            return;
+        }
+        try {
+            await this.redis.connect();
+            // Initialize circuit breakers
+            for (const cbConfig of this.config.circuitBreakers){
+                const circuitBreaker = new CircuitBreaker(cbConfig, this.logger);
+                this.circuitBreakers.set(cbConfig.name, circuitBreaker);
+                circuitBreaker.on('stateChange', (state)=>{
+                    this.emit('circuitBreakerStateChange', {
+                        name: cbConfig.name,
+                        state
+                    });
+                });
+            }
+            // Initialize failover managers
+            for (const foConfig of this.config.failover){
+                const failoverManager = new FailoverManager(foConfig, this.logger, this.redis);
+                this.failoverManagers.set(foConfig.primary.id, failoverManager);
+                failoverManager.on('failover', (state)=>{
+                    this.emit('failover', state);
+                });
+                failoverManager.on('failback', (state)=>{
+                    this.emit('failback', state);
+                });
+            }
+            // Start subsystems
+            await this.healthMonitor.start();
+            await this.disasterRecovery.start();
+            this.isRunning = true;
+            this.logger.info('Resilience architecture started', {
+                circuitBreakers: this.circuitBreakers.size,
+                failoverManagers: this.failoverManagers.size
+            });
+            this.emit('started');
+        } catch (error) {
+            this.logger.error('Failed to start resilience architecture', {
+                error
+            });
+            throw error;
+        }
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        await this.healthMonitor.stop();
+        await this.disasterRecovery.stop();
+        for (const circuitBreaker of this.circuitBreakers.values()){
+            circuitBreaker.destroy();
+        }
+        for (const failoverManager of this.failoverManagers.values()){
+            await failoverManager.stop();
+        }
+        await this.redis.disconnect();
+        this.emit('stopped');
+        this.logger.info('Resilience architecture stopped');
+    }
+    async executeWithResilience(serviceName, operation, options = {}) {
+        const circuitBreaker = this.circuitBreakers.get(serviceName);
+        const failoverManager = this.failoverManagers.get(serviceName);
+        if (!circuitBreaker && !failoverManager) {
+            // No resilience mechanisms configured, execute directly
+            return await this.executeWithTimeout(operation, options.timeout);
+        }
+        // Apply rate limiting
+        await this.rateLimiter.acquire();
+        // Apply bulkhead pattern
+        return await this.bulkheadManager.execute(async ()=>{
+            // Try circuit breaker first
+            if (circuitBreaker) {
+                try {
+                    return await circuitBreaker.execute(operation, options.timeout);
+                } catch (error) {
+                    this.logger.warn('Circuit breaker rejected call', {
+                        serviceName,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                    if (options.fallback) {
+                        return await options.fallback();
+                    }
+                    throw error;
+                }
+            }
+            // Try failover manager
+            if (failoverManager) {
+                return await failoverManager.execute(operation, options);
+            }
+            return await this.executeWithTimeout(operation, options.timeout);
+        });
+    }
+    async executeWithTimeout(operation, timeoutMs = 30000) {
+        return new Promise((resolve, reject)=>{
+            const timer = setTimeout(()=>{
+                reject(new Error(`Operation timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            operation().then((result)=>{
+                clearTimeout(timer);
+                resolve(result);
+            }).catch((error)=>{
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    async getCircuitBreakerStatus(name) {
+        const circuitBreaker = this.circuitBreakers.get(name);
+        return circuitBreaker ? circuitBreaker.getMetrics() : null;
+    }
+    async getFailoverStatus(serviceId) {
+        const failoverManager = this.failoverManagers.get(serviceId);
+        return failoverManager ? failoverManager.getState() : null;
+    }
+    async triggerEmergencyProcedure(procedureId, context = {}) {
+        return await this.disasterRecovery.executeProcedure(procedureId, context);
+    }
+    async manualFailover(serviceId, targetEndpointId) {
+        const failoverManager = this.failoverManagers.get(serviceId);
+        if (!failoverManager) {
+            throw new Error(`No failover manager found for service: ${serviceId}`);
+        }
+        return await failoverManager.manualFailover(targetEndpointId);
+    }
+    async manualFailback(serviceId) {
+        const failoverManager = this.failoverManagers.get(serviceId);
+        if (!failoverManager) {
+            throw new Error(`No failover manager found for service: ${serviceId}`);
+        }
+        return await failoverManager.manualFailback();
+    }
+    async getHealthStatus() {
+        const statuses = [];
+        for (const [serviceId, failoverManager] of this.failoverManagers){
+            const status = await failoverManager.getHealthStatus();
+            statuses.push({
+                service: serviceId,
+                status
+            });
+        }
+        return statuses;
+    }
+    constructor(logger, config){
+        super(), _define_property(this, "redis", void 0), _define_property(this, "logger", void 0), _define_property(this, "config", void 0), _define_property(this, "isRunning", false), _define_property(this, "circuitBreakers", new Map()), _define_property(this, "failoverManagers", new Map()), _define_property(this, "healthMonitor", void 0), _define_property(this, "disasterRecovery", void 0), _define_property(this, "bulkheadManager", void 0), _define_property(this, "rateLimiter", void 0);
+        this.logger = logger;
+        this.config = config;
+        this.redis = createClient(config.redis);
+        this.healthMonitor = new HealthMonitor(logger, config);
+        this.disasterRecovery = new DisasterRecoveryManager(logger, config.disasterRecovery);
+        this.bulkheadManager = new BulkheadManager(config.bulkheads);
+        this.rateLimiter = new RateLimiter(config.rateLimiting);
+    }
+}
+let CircuitBreaker = class CircuitBreaker extends EventEmitter {
+    async execute(operation, timeoutMs) {
+        const startTime = Date.now();
+        try {
+            if (this.state === "open") {
+                if (this.shouldAttemptReset()) {
+                    this.setState("half_open");
+                    this.halfOpenCalls = 0;
+                } else {
+                    throw new Error(`Circuit breaker is OPEN for ${this.config.name}`);
+                }
+            }
+            if (this.state === "half_open" && this.halfOpenCalls >= this.config.halfOpenMaxCalls) {
+                throw new Error(`Circuit breaker is HALF_OPEN and has exceeded max calls for ${this.config.name}`);
+            }
+            if (this.state === "half_open") {
+                this.halfOpenCalls++;
+            }
+            this.totalCalls++;
+            const result = await this.executeWithTimeout(operation, timeoutMs);
+            const responseTime = Date.now() - startTime;
+            this.recordSuccess(responseTime);
+            return result;
+        } catch (error) {
+            this.recordFailure();
+            throw error;
+        }
+    }
+    async executeWithTimeout(operation, timeoutMs) {
+        const timeout = timeoutMs || 30000;
+        return new Promise((resolve, reject)=>{
+            const timer = setTimeout(()=>{
+                this.recordTimeout();
+                reject(new Error(`Operation timed out after ${timeout}ms`));
+            }, timeout);
+            operation().then((result)=>{
+                clearTimeout(timer);
+                resolve(result);
+            }).catch((error)=>{
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    recordSuccess(responseTime) {
+        this.successes++;
+        this.lastSuccessTime = new Date();
+        this.responseTimes.push(responseTime);
+        // Keep only last 100 response times
+        if (this.responseTimes.length > 100) {
+            this.responseTimes = this.responseTimes.slice(-100);
+        }
+        if (this.state === "half_open") {
+            this.setState("closed");
+            this.failures = 0;
+        }
+        this.logger.debug('Circuit breaker success', {
+            name: this.config.name,
+            state: this.state,
+            successes: this.successes,
+            failures: this.failures
+        });
+    }
+    recordFailure() {
+        this.failures++;
+        this.lastFailureTime = new Date();
+        if (this.state === "half_open") {
+            this.setState("open");
+        } else if (this.shouldOpenCircuit()) {
+            this.setState("open");
+        }
+        this.logger.debug('Circuit breaker failure', {
+            name: this.config.name,
+            state: this.state,
+            failures: this.failures,
+            threshold: this.config.failureThreshold
+        });
+    }
+    recordTimeout() {
+        this.timeouts++;
+        this.lastFailureTime = new Date();
+        this.recordFailure();
+    }
+    shouldOpenCircuit() {
+        return this.failures >= this.config.failureThreshold;
+    }
+    shouldAttemptReset() {
+        return Date.now() - this.stateChangedAt.getTime() >= this.config.recoveryTimeout;
+    }
+    setState(newState) {
+        const oldState = this.state;
+        this.state = newState;
+        this.stateChangedAt = new Date();
+        this.logger.info('Circuit breaker state changed', {
+            name: this.config.name,
+            from: oldState,
+            to: newState
+        });
+        this.emit('stateChange', newState);
+        if (this.config.stateChangeHandler) {
+            this.config.stateChangeHandler(newState);
+        }
+    }
+    getMetrics() {
+        return {
+            state: this.state,
+            failures: this.failures,
+            successes: this.successes,
+            timeouts: this.timeouts,
+            totalCalls: this.totalCalls,
+            failureRate: this.totalCalls > 0 ? this.failures / this.totalCalls : 0,
+            lastFailureTime: this.lastFailureTime,
+            lastSuccessTime: this.lastSuccessTime,
+            stateChangedAt: this.stateChangedAt,
+            averageResponseTime: this.responseTimes.length > 0 ? this.responseTimes.reduce((sum, time)=>sum + time, 0) / this.responseTimes.length : 0
+        };
+    }
+    destroy() {
+        this.removeAllListeners();
+    }
+    constructor(config, logger){
+        super(), _define_property(this, "config", void 0), _define_property(this, "logger", void 0), _define_property(this, "state", "closed"), _define_property(this, "failures", 0), _define_property(this, "successes", 0), _define_property(this, "timeouts", 0), _define_property(this, "totalCalls", 0), _define_property(this, "lastFailureTime", void 0), _define_property(this, "lastSuccessTime", void 0), _define_property(this, "stateChangedAt", new Date()), _define_property(this, "halfOpenCalls", 0), _define_property(this, "responseTimes", []);
+        this.config = config;
+        this.logger = logger;
+    }
+};
+let FailoverManager = class FailoverManager extends EventEmitter {
+    async start() {
+        this.startHealthChecks();
+        this.logger.info('Failover manager started', {
+            primary: this.config.primary.id,
+            secondaryCount: this.config.secondary.length
+        });
+    }
+    async stop() {
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+        }
+        this.logger.info('Failover manager stopped');
+    }
+    async execute(operation, options = {}) {
+        const endpoint = this.state.active;
+        try {
+            const result = await operation();
+            this.recordSuccess(endpoint);
+            return result;
+        } catch (error) {
+            this.recordFailure(endpoint, error);
+            if (this.shouldFailover()) {
+                await this.performFailover();
+                // Retry with new endpoint
+                return await operation();
+            }
+            throw error;
+        }
+    }
+    async manualFailover(targetEndpointId) {
+        let targetEndpoint;
+        if (targetEndpointId) {
+            targetEndpoint = this.config.secondary.find((ep)=>ep.id === targetEndpointId) || this.config.secondary.find((ep)=>ep.id === targetEndpointId);
+            if (!targetEndpoint) {
+                throw new Error(`Secondary endpoint not found: ${targetEndpointId}`);
+            }
+        } else {
+            targetEndpoint = this.selectBestSecondary();
+        }
+        await this.performFailoverTo(targetEndpoint);
+        return true;
+    }
+    async manualFailback() {
+        if (!this.state.inFailover) {
+            return false;
+        }
+        const primaryHealthy = this.healthStatuses.get(this.config.primary.id)?.healthy ?? false;
+        if (!primaryHealthy) {
+            this.logger.warn('Cannot failback to unhealthy primary', {
+                primaryId: this.config.primary.id
+            });
+            return false;
+        }
+        await this.performFailback();
+        return true;
+    }
+    startHealthChecks() {
+        this.healthCheckTimer = setInterval(async ()=>{
+            await this.performHealthChecks();
+        }, this.config.healthCheckInterval);
+        // Initial health check
+        this.performHealthChecks();
+    }
+    async performHealthChecks() {
+        const endpoints = [
+            this.config.primary,
+            ...this.config.secondary
+        ];
+        for (const endpoint of endpoints){
+            try {
+                const startTime = Date.now();
+                const healthy = await this.checkEndpointHealth(endpoint);
+                const responseTime = Date.now() - startTime;
+                this.updateHealthStatus(endpoint, healthy, responseTime);
+            } catch (error) {
+                this.updateHealthStatus(endpoint, false, 0, error instanceof Error ? error.message : String(error));
+            }
+        }
+        await this.evaluateFailoverConditions();
+        await this.evaluateFailbackConditions();
+    }
+    async checkEndpointHealth(endpoint) {
+        // Implementation would perform actual health check
+        // For now, simulate with random success
+        return Math.random() > 0.1; // 90% success rate
+    }
+    updateHealthStatus(endpoint, healthy, responseTime, error) {
+        const current = this.healthStatuses.get(endpoint.id) || {
+            endpoint,
+            healthy: true,
+            responseTime: 0,
+            lastCheck: new Date(),
+            consecutiveFailures: 0,
+            consecutiveSuccesses: 0
+        };
+        if (healthy) {
+            current.consecutiveSuccesses++;
+            current.consecutiveFailures = 0;
+        } else {
+            current.consecutiveFailures++;
+            current.consecutiveSuccesses = 0;
+        }
+        current.healthy = healthy;
+        current.responseTime = responseTime;
+        current.lastCheck = new Date();
+        current.error = error;
+        this.healthStatuses.set(endpoint.id, current);
+    }
+    async evaluateFailoverConditions() {
+        if (this.state.inFailover) {
+            return; // Already in failover mode
+        }
+        const primaryStatus = this.healthStatuses.get(this.config.primary.id);
+        if (!primaryStatus || primaryStatus.healthy) {
+            return; // Primary is healthy
+        }
+        const consecutiveFailures = primaryStatus.consecutiveFailures;
+        if (consecutiveFailures >= this.config.failoverThreshold) {
+            await this.performFailover();
+        }
+    }
+    async evaluateFailbackConditions() {
+        if (!this.state.inFailover || !this.config.automaticFailback) {
+            return;
+        }
+        const primaryStatus = this.healthStatuses.get(this.config.primary.id);
+        if (!primaryStatus || !primaryStatus.healthy) {
+            return; // Primary is not healthy
+        }
+        const consecutiveSuccesses = primaryStatus.consecutiveSuccesses;
+        if (consecutiveSuccesses >= this.config.failbackThreshold) {
+            await this.performFailback();
+        }
+    }
+    shouldFailover() {
+        const activeStatus = this.healthStatuses.get(this.state.active.id);
+        return activeStatus ? !activeStatus.healthy : false;
+    }
+    async performFailover() {
+        const targetEndpoint = this.selectBestSecondary();
+        await this.performFailoverTo(targetEndpoint);
+    }
+    async performFailoverTo(targetEndpoint) {
+        const previousActive = this.state.active;
+        this.state.active = targetEndpoint;
+        this.state.inFailover = true;
+        this.state.failoverCount++;
+        this.state.lastFailover = new Date();
+        this.logger.warn('Failover performed', {
+            from: previousActive.id,
+            to: targetEndpoint.id,
+            failoverCount: this.state.failoverCount
+        });
+        this.emit('failover', {
+            previous: previousActive,
+            current: targetEndpoint,
+            state: this.state
+        });
+        // Store failover state in Redis
+        await this.redis.setEx(`swarm:error-recovery-final:failover:${this.config.primary.id}`, 3600, JSON.stringify(this.state));
+    }
+    async performFailback() {
+        const previousActive = this.state.active;
+        this.state.active = this.config.primary;
+        this.state.inFailover = false;
+        this.state.lastFailback = new Date();
+        this.logger.info('Failback performed', {
+            from: previousActive.id,
+            to: this.config.primary.id,
+            duration: Date.now() - this.state.lastFailover.getTime()
+        });
+        this.emit('failback', {
+            previous: previousActive,
+            current: this.config.primary,
+            state: this.state
+        });
+        // Clear failover state from Redis
+        await this.redis.del(`swarm:error-recovery-final:failover:${this.config.primary.id}`);
+    }
+    selectBestSecondary() {
+        const healthySecondaries = this.config.secondary.filter((ep)=>{
+            const status = this.healthStatuses.get(ep.id);
+            return status && status.healthy;
+        });
+        if (healthySecondaries.length === 0) {
+            // No healthy secondaries, select by priority
+            return this.config.secondary.reduce((best, current)=>current.priority < best.priority ? current : best);
+        }
+        // Select healthy secondary with best response time
+        return healthySecondaries.reduce((best, current)=>{
+            const bestStatus = this.healthStatuses.get(best.id);
+            const currentStatus = this.healthStatuses.get(current.id);
+            return currentStatus.responseTime < bestStatus.responseTime ? current : best;
+        });
+    }
+    recordSuccess(endpoint) {
+        const status = this.healthStatuses.get(endpoint.id);
+        if (status) {
+            status.consecutiveSuccesses++;
+            status.consecutiveFailures = 0;
+        }
+    }
+    recordFailure(endpoint, error) {
+        const status = this.healthStatuses.get(endpoint.id);
+        if (status) {
+            status.consecutiveFailures++;
+            status.consecutiveSuccesses = 0;
+            status.error = error instanceof Error ? error.message : String(error);
+        }
+    }
+    getState() {
+        return {
+            ...this.state
+        };
+    }
+    async getHealthStatus() {
+        return this.healthStatuses.get(this.state.active.id) || {
+            endpoint: this.state.active,
+            healthy: false,
+            responseTime: 0,
+            lastCheck: new Date(),
+            consecutiveFailures: 0,
+            consecutiveSuccesses: 0,
+            error: 'No health status available'
+        };
+    }
+    constructor(config, logger, redis){
+        super(), _define_property(this, "config", void 0), _define_property(this, "logger", void 0), _define_property(this, "redis", void 0), _define_property(this, "state", void 0), _define_property(this, "healthStatuses", new Map()), _define_property(this, "healthCheckTimer", void 0);
+        this.config = config;
+        this.logger = logger;
+        this.redis = redis;
+        this.state = {
+            primary: config.primary,
+            active: config.primary,
+            secondary: [
+                ...config.secondary
+            ],
+            failoverCount: 0,
+            lastFailover: new Date(),
+            inFailover: false,
+            automaticFailbackEnabled: config.automaticFailback
+        };
+        // Initialize health statuses
+        this.updateHealthStatus(config.primary, true, 0);
+        config.secondary.forEach((endpoint)=>{
+            this.updateHealthStatus(endpoint, true, 0);
+        });
+    }
+};
+let HealthMonitor = class HealthMonitor {
+    async start() {
+        this.isRunning = true;
+        this.logger.info('Health monitor started');
+    }
+    async stop() {
+        this.isRunning = false;
+        this.logger.info('Health monitor stopped');
+    }
+    constructor(logger, config){
+        _define_property(this, "logger", void 0);
+        _define_property(this, "config", void 0);
+        _define_property(this, "isRunning", false);
+        this.logger = logger;
+        this.config = config;
+    }
+};
+let DisasterRecoveryManager = class DisasterRecoveryManager {
+    async start() {
+        if (!this.config.enabled) {
+            return;
+        }
+        this.isRunning = true;
+        this.logger.info('Disaster recovery manager started');
+    }
+    async stop() {
+        this.isRunning = false;
+        this.logger.info('Disaster recovery manager stopped');
+    }
+    async executeProcedure(procedureId, context = {}) {
+        const procedure = this.config.emergencyProcedures.find((p)=>p.id === procedureId);
+        if (!procedure) {
+            throw new Error(`Emergency procedure not found: ${procedureId}`);
+        }
+        this.logger.warn('Executing emergency procedure', {
+            id: procedureId,
+            name: procedure.name,
+            severity: procedure.severity
+        });
+        try {
+            for (const step of procedure.steps){
+                await this.executeStep(step, context);
+            }
+            this.logger.info('Emergency procedure completed successfully', {
+                id: procedureId
+            });
+            return true;
+        } catch (error) {
+            this.logger.error('Emergency procedure failed', {
+                id: procedureId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return false;
+        }
+    }
+    async executeStep(step, context) {
+        this.logger.debug('Executing emergency step', {
+            id: step.id,
+            name: step.name,
+            action: step.action
+        });
+        // Implementation would execute the actual step
+        // For now, simulate execution
+        await new Promise((resolve)=>setTimeout(resolve, 1000));
+    }
+    constructor(logger, config){
+        _define_property(this, "logger", void 0);
+        _define_property(this, "config", void 0);
+        _define_property(this, "isRunning", false);
+        this.logger = logger;
+        this.config = config;
+    }
+};
+let BulkheadManager = class BulkheadManager {
+    async execute(operation) {
+        if (!this.config.enabled) {
+            return await operation();
+        }
+        return new Promise((resolve, reject)=>{
+            if (this.runningCalls < this.config.maxConcurrentCalls) {
+                this.executeNow(operation, resolve, reject);
+            } else if (this.queue.length < this.config.maxQueueSize) {
+                this.queue.push({
+                    resolve,
+                    reject,
+                    operation
+                });
+            } else {
+                reject(new Error('Bulkhead queue is full'));
+            }
+        });
+    }
+    async executeNow(operation, resolve, reject) {
+        this.runningCalls++;
+        const timeout = setTimeout(()=>{
+            this.runningCalls--;
+            reject(new Error('Bulkhead operation timed out'));
+            this.processQueue();
+        }, this.config.timeout);
+        try {
+            const result = await operation();
+            clearTimeout(timeout);
+            this.runningCalls--;
+            resolve(result);
+            this.processQueue();
+        } catch (error) {
+            clearTimeout(timeout);
+            this.runningCalls--;
+            reject(error);
+            this.processQueue();
+        }
+    }
+    processQueue() {
+        if (this.queue.length === 0 || this.runningCalls >= this.config.maxConcurrentCalls) {
+            return;
+        }
+        const { resolve, reject, operation } = this.queue.shift();
+        this.executeNow(operation, resolve, reject);
+    }
+    constructor(config){
+        _define_property(this, "config", void 0);
+        _define_property(this, "runningCalls", 0);
+        _define_property(this, "queue", []);
+        this.config = config;
+    }
+};
+let RateLimiter = class RateLimiter {
+    async acquire() {
+        if (!this.config.enabled) {
+            return;
+        }
+        this.refillTokens();
+        if (this.tokens >= 1) {
+            this.tokens--;
+            return;
+        }
+        // Wait for token refill
+        const waitTime = Math.ceil(1000 / this.config.requestsPerSecond);
+        await new Promise((resolve)=>setTimeout(resolve, waitTime));
+        await this.acquire();
+    }
+    refillTokens() {
+        const now = Date.now();
+        const timePassed = now - this.lastRefill;
+        const tokensToAdd = Math.floor(timePassed * this.config.requestsPerSecond / 1000);
+        if (tokensToAdd > 0) {
+            this.tokens = Math.min(this.tokens + tokensToAdd, this.config.burstSize);
+            this.lastRefill = now;
+        }
+    }
+    constructor(config){
+        _define_property(this, "config", void 0);
+        _define_property(this, "tokens", 0);
+        _define_property(this, "lastRefill", Date.now());
+        this.config = config;
+        this.tokens = config.requestsPerSecond;
+    }
+};