claude-flow-novice 2.0.3 → 2.0.5

package/dist/src/web/api/apm-routes.js

@@ -0,0 +1,353 @@
+/**
+ * APM API Routes
+ * REST API endpoints for APM integration, health checks, and metrics
+ */ import { Router } from "express";
+import { createAPMIntegration } from "../../monitoring/apm/apm-integration.js";
+const router = Router();
+// Initialize APM integration with environment configuration
+const apmIntegration = createAPMIntegration({
+    dataDog: {
+        enabled: process.env.DATADOG_ENABLED === 'true',
+        apiKey: process.env.DATADOG_API_KEY,
+        site: process.env.DATADOG_SITE || 'datadoghq.com',
+        serviceName: process.env.DATADOG_SERVICE_NAME || 'claude-flow-novice',
+        env: process.env.NODE_ENV || 'production',
+        version: process.env.npm_package_version || '1.6.2'
+    },
+    newRelic: {
+        enabled: process.env.NEWRELIC_ENABLED === 'true',
+        licenseKey: process.env.NEWRELIC_LICENSE_KEY,
+        appName: process.env.NEWRELIC_APP_NAME || 'Claude Flow Novice',
+        accountId: process.env.NEWRELIC_ACCOUNT_ID
+    },
+    distributedTracing: {
+        enabled: process.env.DISTRIBUTED_TRACING_ENABLED !== 'false',
+        samplingRate: parseFloat(process.env.TRACE_SAMPLING_RATE || '1.0')
+    },
+    performanceOptimization: {
+        enabled: process.env.PERFORMANCE_OPTIMIZATION_ENABLED !== 'false',
+        monitoringInterval: parseInt(process.env.PERFORMANCE_MONITORING_INTERVAL || '5000')
+    },
+    customMetrics: {
+        enabled: process.env.CUSTOM_METRICS_ENABLED !== 'false',
+        interval: parseInt(process.env.CUSTOM_METRICS_INTERVAL || '10000')
+    },
+    alerting: {
+        enabled: process.env.APM_ALERTING_ENABLED === 'true',
+        webhookUrl: process.env.APM_WEBHOOK_URL,
+        slackChannel: process.env.APM_SLACK_CHANNEL,
+        emailRecipients: process.env.APM_EMAIL_RECIPIENTS?.split(',').filter(Boolean)
+    }
+});
+// Health check endpoint
+router.get('/health', async (req, res)=>{
+    try {
+        const health = await apmIntegration.getHealthStatus();
+        const statusCode = health.overall === 'healthy' ? 200 : health.overall === 'degraded' ? 200 : 503;
+        res.status(statusCode).json(health);
+    } catch (error) {
+        console.error('Health check failed:', error);
+        res.status(500).json({
+            error: 'Health check failed',
+            message: error.message
+        });
+    }
+});
+// Performance metrics endpoint
+router.get('/metrics', async (req, res)=>{
+    try {
+        const timeRange = req.query.timeRange || '1h';
+        const analytics = apmIntegration.getPerformanceAnalytics();
+        res.json({
+            timeRange,
+            timestamp: new Date().toISOString(),
+            ...analytics
+        });
+    } catch (error) {
+        console.error('Failed to fetch metrics:', error);
+        res.status(500).json({
+            error: 'Failed to fetch metrics',
+            message: error.message
+        });
+    }
+});
+// Custom metrics recording endpoint
+router.post('/metrics/custom', async (req, res)=>{
+    try {
+        const { metricName, value, tags, type } = req.body;
+        if (!metricName || value === undefined) {
+            return res.status(400).json({
+                error: 'Missing required fields: metricName, value'
+            });
+        }
+        apmIntegration.recordBusinessMetric(metricName, value, tags, type);
+        res.json({
+            success: true,
+            message: 'Custom metric recorded successfully',
+            metricName,
+            value,
+            tags,
+            type: type || 'gauge'
+        });
+    } catch (error) {
+        console.error('Failed to record custom metric:', error);
+        res.status(500).json({
+            error: 'Failed to record custom metric',
+            message: error.message
+        });
+    }
+});
+// Agent lifecycle tracing endpoint
+router.post('/trace/agent', async (req, res)=>{
+    try {
+        const { agentType, lifecycleEvent, agentId, metadata } = req.body;
+        if (!agentType || !lifecycleEvent) {
+            return res.status(400).json({
+                error: 'Missing required fields: agentType, lifecycleEvent'
+            });
+        }
+        apmIntegration.traceAgentLifecycle(agentType, lifecycleEvent, agentId, metadata);
+        res.json({
+            success: true,
+            message: 'Agent lifecycle trace recorded successfully',
+            agentType,
+            lifecycleEvent,
+            agentId,
+            metadata
+        });
+    } catch (error) {
+        console.error('Failed to trace agent lifecycle:', error);
+        res.status(500).json({
+            error: 'Failed to trace agent lifecycle',
+            message: error.message
+        });
+    }
+});
+// Swarm activity tracing endpoint
+router.post('/trace/swarm', async (req, res)=>{
+    try {
+        const { swarmId, activity, topology, agentCount, metadata } = req.body;
+        if (!swarmId || !activity || !topology) {
+            return res.status(400).json({
+                error: 'Missing required fields: swarmId, activity, topology'
+            });
+        }
+        apmIntegration.traceSwarmActivity(swarmId, activity, topology, agentCount, metadata);
+        res.json({
+            success: true,
+            message: 'Swarm activity trace recorded successfully',
+            swarmId,
+            activity,
+            topology,
+            agentCount,
+            metadata
+        });
+    } catch (error) {
+        console.error('Failed to trace swarm activity:', error);
+        res.status(500).json({
+            error: 'Failed to trace swarm activity',
+            message: error.message
+        });
+    }
+});
+// WebSocket performance endpoint
+router.post('/trace/websocket', async (req, res)=>{
+    try {
+        const { operation, socketId, duration, success, metadata } = req.body;
+        if (!operation || !socketId) {
+            return res.status(400).json({
+                error: 'Missing required fields: operation, socketId'
+            });
+        }
+        apmIntegration.optimizeWebSocketPerformance(operation, socketId, duration, success, metadata);
+        res.json({
+            success: true,
+            message: 'WebSocket performance trace recorded successfully',
+            operation,
+            socketId,
+            duration,
+            success,
+            metadata
+        });
+    } catch (error) {
+        console.error('Failed to trace WebSocket performance:', error);
+        res.status(500).json({
+            error: 'Failed to trace WebSocket performance',
+            message: error.message
+        });
+    }
+});
+// Database performance monitoring endpoint
+router.post('/trace/database', async (req, res)=>{
+    try {
+        const { operation, query, duration, success, metadata } = req.body;
+        if (!operation) {
+            return res.status(400).json({
+                error: 'Missing required field: operation'
+            });
+        }
+        apmIntegration.monitorDatabasePerformance(operation, query, duration, success, metadata);
+        res.json({
+            success: true,
+            message: 'Database performance trace recorded successfully',
+            operation,
+            query,
+            duration,
+            success,
+            metadata
+        });
+    } catch (error) {
+        console.error('Failed to monitor database performance:', error);
+        res.status(500).json({
+            error: 'Failed to monitor database performance',
+            message: error.message
+        });
+    }
+});
+// Integration test endpoint
+router.post('/test/integration', async (req, res)=>{
+    try {
+        const results = await apmIntegration.runIntegrationTest();
+        res.json({
+            success: true,
+            results
+        });
+    } catch (error) {
+        console.error('Integration test failed:', error);
+        res.status(500).json({
+            error: 'Integration test failed',
+            message: error.message
+        });
+    }
+});
+// Disaster recovery test endpoint
+router.post('/test/disaster-recovery', async (req, res)=>{
+    try {
+        const results = await apmIntegration.runDisasterRecoveryTest();
+        res.json({
+            success: true,
+            results
+        });
+    } catch (error) {
+        console.error('Disaster recovery test failed:', error);
+        res.status(500).json({
+            error: 'Disaster recovery test failed',
+            message: error.message
+        });
+    }
+});
+// Configuration endpoint
+router.get('/config', (req, res)=>{
+    try {
+        const collectors = apmIntegration.getCollectors();
+        res.json({
+            dataDog: !!collectors.dataDog,
+            newRelic: !!collectors.newRelic,
+            distributedTracing: !!collectors.distributedTracer,
+            performanceOptimizer: !!collectors.performanceOptimizer,
+            timestamp: new Date().toISOString()
+        });
+    } catch (error) {
+        console.error('Failed to get APM config:', error);
+        res.status(500).json({
+            error: 'Failed to get APM configuration',
+            message: error.message
+        });
+    }
+});
+// Recommendations endpoint
+router.get('/recommendations', (req, res)=>{
+    try {
+        const analytics = apmIntegration.getPerformanceAnalytics();
+        res.json({
+            recommendations: analytics.recommendations,
+            timestamp: new Date().toISOString()
+        });
+    } catch (error) {
+        console.error('Failed to get recommendations:', error);
+        res.status(500).json({
+            error: 'Failed to get recommendations',
+            message: error.message
+        });
+    }
+});
+// Slow queries endpoint
+router.get('/slow-queries', (req, res)=>{
+    try {
+        const collectors = apmIntegration.getCollectors();
+        if (!collectors.performanceOptimizer) {
+            return res.status(503).json({
+                error: 'Performance optimizer not available'
+            });
+        }
+        const slowQueries = collectors.performanceOptimizer.getSlowQueries();
+        res.json({
+            slowQueries,
+            count: slowQueries.length,
+            timestamp: new Date().toISOString()
+        });
+    } catch (error) {
+        console.error('Failed to get slow queries:', error);
+        res.status(500).json({
+            error: 'Failed to get slow queries',
+            message: error.message
+        });
+    }
+});
+// Cache performance endpoint
+router.get('/cache-performance', (req, res)=>{
+    try {
+        const collectors = apmIntegration.getCollectors();
+        if (!collectors.performanceOptimizer) {
+            return res.status(503).json({
+                error: 'Performance optimizer not available'
+            });
+        }
+        const cacheHitRates = collectors.performanceOptimizer.getCacheHitRates();
+        res.json({
+            cacheHitRates: Object.fromEntries(cacheHitRates),
+            timestamp: new Date().toISOString()
+        });
+    } catch (error) {
+        console.error('Failed to get cache performance:', error);
+        res.status(500).json({
+            error: 'Failed to get cache performance',
+            message: error.message
+        });
+    }
+});
+// Middleware to add APM tracing to all requests
+router.use((req, res, next)=>{
+    const startTime = Date.now();
+    // Extract trace context from headers
+    const traceContext = {
+        traceId: req.headers['x-trace-id'],
+        spanId: req.headers['x-span-id'],
+        parentSpanId: req.headers['x-parent-span-id']
+    };
+    // Record the request
+    res.on('finish', ()=>{
+        const duration = Date.now() - startTime;
+        const success = res.statusCode < 400;
+        // Record API call metrics
+        if (traceContext.traceId) {
+            // This is part of an existing trace
+            apmIntegration.monitorDatabasePerformance('api_request', undefined, duration, success, {
+                method: req.method,
+                route: req.route?.path || req.path,
+                statusCode: res.statusCode.toString(),
+                userAgent: req.headers['user-agent']
+            });
+        } else {
+            // Create a new trace for this request
+            apmIntegration.traceAgentLifecycle('api-gateway', 'execute', undefined, {
+                method: req.method,
+                route: req.route?.path || req.path,
+                statusCode: res.statusCode.toString(),
+                duration: duration.toString()
+            });
+        }
+    });
+    next();
+});
+export default router;

package/dist/src/web/api/config/api-config.js

@@ -0,0 +1,184 @@
+/**
+ * API Server Configuration
+ *
+ * Configuration settings for the transparency API server
+ * including security, CORS, rate limiting, and other options.
+ *
+ * @module web/api/config/api-config
+ */ /**
+ * Create default API configuration
+ */ export function createApiConfig() {
+    const env = process.env.NODE_ENV || 'development';
+    return {
+        port: parseInt(process.env.API_PORT || '3001', 10),
+        host: process.env.API_HOST || 'localhost',
+        environment: env,
+        // CORS configuration
+        corsOrigins: env === 'production' ? process.env.CORS_ORIGINS?.split(',') || [
+            'https://localhost:3000'
+        ] : [
+            'http://localhost:3000',
+            'http://localhost:3001',
+            'http://127.0.0.1:3000'
+        ],
+        // Rate limiting
+        rateLimitWindowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS || '900000', 10),
+        rateLimitMax: parseInt(process.env.RATE_LIMIT_MAX || '100', 10),
+        // Security
+        sessionSecret: process.env.SESSION_SECRET || 'change-me-in-production',
+        jwtSecret: process.env.JWT_SECRET || 'change-me-in-production',
+        jwtExpiration: process.env.JWT_EXPIRATION || '24h',
+        apiKey: process.env.API_KEY || 'change-me-in-production',
+        // Logging
+        logLevel: process.env.LOG_LEVEL || 'info',
+        // Performance
+        cacheTtl: parseInt(process.env.CACHE_TTL || '5000', 10),
+        enableCompression: process.env.ENABLE_COMPRESSION !== 'false',
+        // HTTPS
+        enableHttps: process.env.ENABLE_HTTPS === 'true',
+        sslCertPath: process.env.SSL_CERT_PATH,
+        sslKeyPath: process.env.SSL_KEY_PATH,
+        // Metrics
+        enableMetrics: process.env.ENABLE_METRICS !== 'false',
+        metricsIntervalMs: parseInt(process.env.METRICS_INTERVAL_MS || '60000', 10),
+        // Request handling
+        maxRequestBodySize: process.env.MAX_REQUEST_BODY_SIZE || '10mb',
+        requestTimeoutMs: parseInt(process.env.REQUEST_TIMEOUT_MS || '30000', 10),
+        // WebSocket
+        websocketPingTimeoutMs: parseInt(process.env.WS_PING_TIMEOUT_MS || '60000', 10),
+        websocketPingIntervalMs: parseInt(process.env.WS_PING_INTERVAL_MS || '25000', 10),
+        maxWebSocketConnections: parseInt(process.env.MAX_WS_CONNECTIONS || '100', 10),
+        // Features
+        enableRequestLogging: process.env.ENABLE_REQUEST_LOGGING !== 'false',
+        enableDetailedErrors: env === 'development',
+        // API info
+        apiVersion: process.env.API_VERSION || '1.0.0',
+        serverName: process.env.SERVER_NAME || 'Transparency API Server'
+    };
+}
+/**
+ * Validate API configuration
+ */ export function validateApiConfig(config) {
+    const errors = [];
+    if (config.port < 1 || config.port > 65535) {
+        errors.push('Port must be between 1 and 65535');
+    }
+    if (config.rateLimitWindowMs < 1000) {
+        errors.push('Rate limit window must be at least 1000ms');
+    }
+    if (config.rateLimitMax < 1) {
+        errors.push('Rate limit max must be at least 1');
+    }
+    if (config.cacheTtl < 0) {
+        errors.push('Cache TTL cannot be negative');
+    }
+    if (config.requestTimeoutMs < 1000) {
+        errors.push('Request timeout must be at least 1000ms');
+    }
+    if (config.websocketPingTimeoutMs < 5000) {
+        errors.push('WebSocket ping timeout must be at least 5000ms');
+    }
+    if (config.websocketPingIntervalMs < 1000) {
+        errors.push('WebSocket ping interval must be at least 1000ms');
+    }
+    if (config.maxWebSocketConnections < 1) {
+        errors.push('Max WebSocket connections must be at least 1');
+    }
+    if (config.enableHttps && (!config.sslCertPath || !config.sslKeyPath)) {
+        errors.push('SSL certificate and key paths are required when HTTPS is enabled');
+    }
+    // In production, check for proper security settings
+    if (config.environment === 'production') {
+        const insecureDefaults = [
+            config.sessionSecret === 'change-me-in-production',
+            config.jwtSecret === 'change-me-in-production',
+            config.apiKey === 'change-me-in-production'
+        ];
+        if (insecureDefaults.some(Boolean)) {
+            errors.push('Production environment requires secure secrets and API keys');
+        }
+        if (config.corsOrigins.includes('*') || config.corsOrigins.includes('http://localhost:*')) {
+            errors.push('Production environment should not use wildcard or localhost CORS origins');
+        }
+        if (config.enableDetailedErrors) {
+            errors.push('Detailed errors should be disabled in production');
+        }
+    }
+    return errors;
+}
+/**
+ * Create CORS options from configuration
+ */ export function createCorsOptions(config) {
+    return {
+        origin: (origin, callback)=>{
+            // Allow requests with no origin (like mobile apps or curl requests)
+            if (!origin) return callback(null, true);
+            if (config.corsOrigins.includes('*') || config.corsOrigins.includes(origin) || config.corsOrigins.some((allowed)=>{
+                // Support wildcard patterns like http://localhost:*
+                if (allowed.includes('*')) {
+                    const pattern = allowed.replace('*', '.*');
+                    const regex = new RegExp(`^${pattern}$`);
+                    return regex.test(origin);
+                }
+                return false;
+            })) {
+                callback(null, true);
+            } else {
+                callback(new Error('Not allowed by CORS'), false);
+            }
+        },
+        methods: [
+            'GET',
+            'POST',
+            'PUT',
+            'DELETE',
+            'PATCH',
+            'OPTIONS'
+        ],
+        allowedHeaders: [
+            'Content-Type',
+            'Authorization',
+            'X-Requested-With',
+            'X-API-Key'
+        ],
+        credentials: true,
+        preflightContinue: false,
+        optionsSuccessStatus: 204
+    };
+}
+/**
+ * Get environment-specific configuration overrides
+ */ export function getEnvironmentOverrides(env) {
+    switch(env){
+        case 'production':
+            return {
+                logLevel: 'warn',
+                enableDetailedErrors: false,
+                enableRequestLogging: false,
+                cacheTtl: 30000,
+                rateLimitMax: 1000,
+                requestTimeoutMs: 60000
+            };
+        case 'test':
+            return {
+                port: 0,
+                host: '127.0.0.1',
+                logLevel: 'error',
+                enableRequestLogging: false,
+                enableMetrics: false,
+                cacheTtl: 100,
+                rateLimitMax: 1000,
+                maxWebSocketConnections: 10
+            };
+        case 'development':
+        default:
+            return {
+                logLevel: 'debug',
+                enableDetailedErrors: true,
+                enableRequestLogging: true,
+                enableMetrics: true,
+                cacheTtl: 5000,
+                rateLimitMax: 1000
+            };
+    }
+}