claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/web/api/server.js

@@ -0,0 +1,462 @@
+/**
+ * Express.js API Server for Transparency Dashboard
+ *
+ * Provides REST API endpoints and WebSocket server for real-time
+ * transparency system data visualization and monitoring.
+ *
+ * @module web/api/server
+ */ 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 express from "express";
+import { createServer } from "http";
+import { Server as SocketIOServer } from "socket.io";
+import cors from "cors";
+import helmet from "helmet";
+import compression from "compression";
+import rateLimit from "express-rate-limit";
+import { v4 as uuidv4 } from "uuid";
+import { TransparencySystem } from "../../coordination/shared/transparency/transparency-system.js";
+import { authMiddleware } from "./middleware/auth.js";
+import { errorHandler } from "./middleware/error-handler.js";
+import { requestLogger } from "./middleware/request-logger.js";
+import { cacheMiddleware } from "./middleware/cache.js";
+import { hierarchyRoutes, statusRoutes, eventsRoutes, metricsRoutes, analyticsRoutes, systemRoutes } from "./routes";
+import { createApiConfig } from "./config/api-config.js";
+import { Logger } from "../../core/logger.js";
+/**
+ * API Server for Transparency Dashboard
+ *
+ * Provides comprehensive REST API and WebSocket server for:
+ * - Agent hierarchy visualization
+ * - Real-time agent status monitoring
+ * - Lifecycle event streaming
+ * - Performance metrics
+ * - System analytics
+ */ export class TransparencyApiServer {
+    /**
+   * Start the API server
+   */ async start() {
+        if (this.isStarted) {
+            this.logger.warn('API server already started');
+            return;
+        }
+        this.logger.info('Starting Transparency API Server', {
+            port: this.config.port,
+            host: this.config.host,
+            environment: this.config.environment
+        });
+        // Initialize transparency system
+        await this.config.transparencySystem.initialize({
+            enableRealTimeMonitoring: true,
+            enableEventStreaming: true,
+            metricsUpdateIntervalMs: 5000,
+            heartbeatIntervalMs: 10000
+        });
+        await this.config.transparencySystem.startMonitoring();
+        // Start HTTP server
+        return new Promise((resolve, reject)=>{
+            this.server.listen(this.config.port, this.config.host, (err)=>{
+                if (err) {
+                    this.logger.error('Failed to start API server', err);
+                    reject(err);
+                    return;
+                }
+                this.isStarted = true;
+                this.logger.info('Transparency API Server started successfully', {
+                    url: `http://${this.config.host}:${this.config.port}`,
+                    environment: this.config.environment,
+                    nodeVersion: process.version
+                });
+                resolve();
+            });
+        });
+    }
+    /**
+   * Stop the API server
+   */ async stop() {
+        if (!this.isStarted) {
+            return;
+        }
+        this.logger.info('Stopping Transparency API Server');
+        // Stop transparency system
+        await this.config.transparencySystem.stopMonitoring();
+        await this.config.transparencySystem.cleanup();
+        // Close WebSocket connections
+        this.io.close();
+        // Close HTTP server
+        return new Promise((resolve)=>{
+            this.server.close(()=>{
+                this.isStarted = false;
+                this.logger.info('Transparency API Server stopped');
+                resolve();
+            });
+        });
+    }
+    /**
+   * Get Express app instance (for testing)
+   */ getApp() {
+        return this.app;
+    }
+    /**
+   * Get Socket.IO server instance
+   */ getSocketIOServer() {
+        return this.io;
+    }
+    /**
+   * Get server configuration
+   */ getConfig() {
+        return {
+            ...this.config
+        };
+    }
+    /**
+   * Setup Express middleware
+   */ setupMiddleware() {
+        // Security middleware
+        this.app.use(helmet({
+            contentSecurityPolicy: {
+                directives: {
+                    defaultSrc: [
+                        "'self'"
+                    ],
+                    styleSrc: [
+                        "'self'",
+                        "'unsafe-inline'"
+                    ],
+                    scriptSrc: [
+                        "'self'"
+                    ],
+                    imgSrc: [
+                        "'self'",
+                        "data:",
+                        "https:"
+                    ],
+                    connectSrc: [
+                        "'self'",
+                        "ws:",
+                        "wss:"
+                    ]
+                }
+            }
+        }));
+        // CORS configuration
+        this.app.use(cors({
+            origin: this.config.corsOrigins,
+            methods: [
+                'GET',
+                'POST',
+                'PUT',
+                'DELETE',
+                'PATCH',
+                'OPTIONS'
+            ],
+            allowedHeaders: [
+                'Content-Type',
+                'Authorization',
+                'X-Requested-With'
+            ],
+            credentials: true,
+            preflightContinue: false,
+            optionsSuccessStatus: 204
+        }));
+        // Compression
+        this.app.use(compression());
+        // Body parsing
+        this.app.use(express.json({
+            limit: '10mb'
+        }));
+        this.app.use(express.urlencoded({
+            extended: true,
+            limit: '10mb'
+        }));
+        // Request logging
+        this.app.use(requestLogger(this.logger));
+        // Rate limiting
+        const limiter = rateLimit({
+            windowMs: 15 * 60 * 1000,
+            max: this.config.rateLimitWindowMs,
+            message: {
+                error: 'Too many requests',
+                message: 'Rate limit exceeded. Please try again later.'
+            },
+            standardHeaders: true,
+            legacyHeaders: false
+        });
+        this.app.use('/api', limiter);
+        // Cache middleware for GET requests
+        this.app.use('/api', cacheMiddleware(this.dataCache));
+        // Authentication middleware (optional for public endpoints)
+        this.app.use('/api/v1', authMiddleware(this.config));
+    }
+    /**
+   * Setup API routes
+   */ setupRoutes() {
+        // Health check endpoint
+        if (this.config.enableHealthCheck) {
+            this.app.get('/health', (req, res)=>{
+                res.json({
+                    status: 'healthy',
+                    timestamp: new Date().toISOString(),
+                    uptime: process.uptime(),
+                    version: process.env.npm_package_version || '1.0.0',
+                    environment: this.config.environment
+                });
+            });
+        }
+        // API documentation
+        if (this.config.enableApiDocs) {
+            this.app.get('/api', (req, res)=>{
+                res.json({
+                    name: 'Transparency API Server',
+                    version: '1.0.0',
+                    description: 'REST API for agent transparency system monitoring',
+                    endpoints: {
+                        hierarchy: '/api/v1/hierarchy',
+                        status: '/api/v1/status',
+                        events: '/api/v1/events',
+                        metrics: '/api/v1/metrics',
+                        analytics: '/api/v1/analytics',
+                        system: '/api/v1/system'
+                    },
+                    websocket: '/socket.io',
+                    documentation: '/api/docs'
+                });
+            });
+        }
+        // API version 1 routes
+        this.app.use('/api/v1/hierarchy', hierarchyRoutes(this.config.transparencySystem, this.logger));
+        this.app.use('/api/v1/status', statusRoutes(this.config.transparencySystem, this.logger));
+        this.app.use('/api/v1/events', eventsRoutes(this.config.transparencySystem, this.logger));
+        this.app.use('/api/v1/metrics', metricsRoutes(this.config.transparencySystem, this.logger));
+        this.app.use('/api/v1/analytics', analyticsRoutes(this.config.transparencySystem, this.logger));
+        this.app.use('/api/v1/system', systemRoutes(this.config, this.logger));
+        // 404 handler
+        this.app.use('*', (req, res)=>{
+            res.status(404).json({
+                error: 'Not Found',
+                message: `Endpoint ${req.method} ${req.originalUrl} not found`,
+                timestamp: new Date().toISOString()
+            });
+        });
+    }
+    /**
+   * Setup WebSocket server for real-time updates
+   */ setupWebSocket() {
+        this.logger.info('Setting up WebSocket server for real-time updates');
+        // WebSocket authentication
+        if (this.config.enableWebSocketAuth) {
+            this.io.use(async (socket, next)=>{
+                try {
+                    const token = socket.handshake.auth.token || socket.handshake.headers.authorization?.replace('Bearer ', '');
+                    if (!token) {
+                        return next(new Error('Authentication required'));
+                    }
+                    // Validate token (implement your token validation logic)
+                    // For now, we'll accept any non-empty token
+                    if (token.length > 0) {
+                        socket.data.userId = 'user-' + uuidv4().slice(0, 8);
+                        next();
+                    } else {
+                        next(new Error('Invalid token'));
+                    }
+                } catch (error) {
+                    next(new Error('Authentication failed'));
+                }
+            });
+        }
+        // Handle WebSocket connections
+        this.io.on('connection', (socket)=>{
+            this.logger.info('WebSocket client connected', {
+                socketId: socket.id,
+                userId: socket.data.userId
+            });
+            // Join rooms based on subscriptions
+            socket.on('subscribe', (data)=>{
+                const { channels } = data;
+                if (Array.isArray(channels)) {
+                    channels.forEach((channel)=>{
+                        socket.join(channel);
+                        this.logger.debug('Client subscribed to channel', {
+                            socketId: socket.id,
+                            channel
+                        });
+                    });
+                }
+            });
+            // Unsubscribe from channels
+            socket.on('unsubscribe', (data)=>{
+                const { channels } = data;
+                if (Array.isArray(channels)) {
+                    channels.forEach((channel)=>{
+                        socket.leave(channel);
+                        this.logger.debug('Client unsubscribed from channel', {
+                            socketId: socket.id,
+                            channel
+                        });
+                    });
+                }
+            });
+            // Handle disconnection
+            socket.on('disconnect', (reason)=>{
+                this.logger.info('WebSocket client disconnected', {
+                    socketId: socket.id,
+                    reason
+                });
+            });
+        });
+        // Register transparency system event listeners for real-time updates
+        this.setupTransparencyEventListeners();
+    }
+    /**
+   * Setup transparency system event listeners for WebSocket broadcasts
+   */ setupTransparencyEventListeners() {
+        const transparency = this.config.transparencySystem;
+        // Agent state changes
+        transparency.on('agentStateChanged', (data)=>{
+            this.io.to('agent-status').emit('agentStateChange', {
+                type: 'agent_state_change',
+                data,
+                timestamp: new Date().toISOString()
+            });
+        });
+        // Agent hierarchy changes
+        transparency.on('hierarchyChange', (data)=>{
+            this.io.to('hierarchy').emit('hierarchyChange', {
+                type: 'hierarchy_change',
+                data,
+                timestamp: new Date().toISOString()
+            });
+        });
+        // Lifecycle events
+        transparency.on('lifecycleEvent', (data)=>{
+            this.io.to('events').emit('lifecycleEvent', {
+                type: 'lifecycle_event',
+                data,
+                timestamp: new Date().toISOString()
+            });
+        });
+        // Metrics updates
+        transparency.on('metricsUpdate', (data)=>{
+            this.io.to('metrics').emit('metricsUpdate', {
+                type: 'metrics_update',
+                data,
+                timestamp: new Date().toISOString()
+            });
+        });
+        // Performance alerts
+        transparency.on('performanceAlert', (data)=>{
+            this.io.to('alerts').emit('performanceAlert', {
+                type: 'performance_alert',
+                data,
+                timestamp: new Date().toISOString()
+            });
+        });
+    }
+    /**
+   * Setup error handling
+   */ setupErrorHandling() {
+        // Global error handler
+        this.app.use(errorHandler(this.logger));
+        // Handle unhandled promise rejections
+        process.on('unhandledRejection', (reason, promise)=>{
+            this.logger.error('Unhandled Promise Rejection', {
+                reason,
+                promise
+            });
+        });
+        // Handle uncaught exceptions
+        process.on('uncaughtException', (error)=>{
+            this.logger.error('Uncaught Exception', error);
+            process.exit(1);
+        });
+    }
+    /**
+   * Get cached data or fetch and cache new data
+   */ async getCachedData(key, fetchFn, ttl = 5000) {
+        const cached = this.dataCache.get(key);
+        const now = Date.now();
+        if (cached && now - cached.timestamp < cached.ttl) {
+            return cached.data;
+        }
+        const data = await fetchFn();
+        this.dataCache.set(key, {
+            data,
+            timestamp: now,
+            ttl
+        });
+        return data;
+    }
+    /**
+   * Clear cache for specific key or all cache
+   */ clearCache(key) {
+        if (key) {
+            this.dataCache.delete(key);
+        } else {
+            this.dataCache.clear();
+        }
+    }
+    constructor(config = {}){
+        _define_property(this, "app", void 0);
+        _define_property(this, "server", void 0);
+        _define_property(this, "io", void 0);
+        _define_property(this, "config", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "isStarted", false);
+        // Data cache for performance
+        _define_property(this, "dataCache", new Map());
+        this.config = {
+            ...createApiConfig(),
+            transparencySystem: new TransparencySystem(),
+            enableWebSocketAuth: true,
+            enableApiDocs: true,
+            enableHealthCheck: true,
+            ...config
+        };
+        this.logger = new Logger({
+            level: this.config.logLevel,
+            format: 'json',
+            destination: 'console'
+        });
+        this.app = express();
+        this.server = createServer(this.app);
+        this.io = new SocketIOServer(this.server, {
+            cors: {
+                origin: this.config.corsOrigins,
+                methods: [
+                    'GET',
+                    'POST'
+                ],
+                credentials: true
+            },
+            transports: [
+                'websocket',
+                'polling'
+            ]
+        });
+        this.setupMiddleware();
+        this.setupRoutes();
+        this.setupWebSocket();
+        this.setupErrorHandling();
+    }
+}
+/**
+ * Create and start API server with default configuration
+ */ export async function createApiServer(config) {
+    const server = new TransparencyApiServer(config);
+    await server.start();
+    return server;
+}
+/**
+ * Default export
+ */ export default TransparencyApiServer;