claude-flow-novice 2.0.3 → 2.0.5

package/dist/src/web/portal-server.js

@@ -0,0 +1,460 @@
+/**
+ * Claude Flow Personal Web Portal Server
+ * Main server entry point with MCP integration and real-time WebSocket support
+ */ 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 path from "path";
+import fs from "node:fs/promises";
+import { loadConfig } from "../config/web-portal-config.js";
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+export class WebPortalServer {
+    setupMiddleware() {
+        // Security middleware
+        this.app.use(helmet({
+            contentSecurityPolicy: {
+                directives: {
+                    defaultSrc: [
+                        "'self'"
+                    ],
+                    styleSrc: [
+                        "'self'",
+                        "'unsafe-inline'",
+                        'https://fonts.googleapis.com'
+                    ],
+                    fontSrc: [
+                        "'self'",
+                        'https://fonts.gstatic.com'
+                    ],
+                    scriptSrc: [
+                        "'self'",
+                        "'unsafe-inline'",
+                        'https://cdn.socket.io'
+                    ],
+                    connectSrc: [
+                        "'self'",
+                        `ws://localhost:${this.config.server.port}`,
+                        `wss://localhost:${this.config.server.port}`
+                    ]
+                }
+            }
+        }));
+        // CORS configuration
+        this.app.use(cors({
+            origin: this.config.cors.allowedOrigins,
+            credentials: true
+        }));
+        // Rate limiting
+        // Express v5 compatibility: Use regex pattern for API routes
+        const limiter = rateLimit({
+            windowMs: 15 * 60 * 1000,
+            max: this.config.security.rateLimit.maxRequests,
+            message: 'Too many requests from this IP, please try again later.',
+            standardHeaders: true,
+            legacyHeaders: false
+        });
+        // Apply to all API routes using regex (Express v5 + path-to-regexp v8 compatible)
+        this.app.use(/^\/api\/.*/, limiter);
+        // Compression and parsing
+        this.app.use(compression());
+        this.app.use(express.json({
+            limit: '10mb'
+        }));
+        this.app.use(express.urlencoded({
+            extended: true,
+            limit: '10mb'
+        }));
+        // Static files
+        if (this.config.frontend.staticPath) {
+            this.app.use(express.static(this.config.frontend.staticPath));
+        }
+    }
+    setupRoutes() {
+        // Health check endpoint
+        this.app.get('/api/health', (req, res)=>{
+            res.json({
+                status: 'ok',
+                timestamp: new Date().toISOString(),
+                uptime: process.uptime(),
+                memory: process.memoryUsage(),
+                mcpConnections: Array.from(this.mcpConnections.entries()).map(([name, conn])=>({
+                        name,
+                        status: conn.status,
+                        lastPing: conn.lastPing
+                    }))
+            });
+        });
+        // MCP status endpoint
+        this.app.get('/api/mcp/status', (req, res)=>{
+            res.json({
+                connections: Array.from(this.mcpConnections.entries()).map(([name, conn])=>({
+                        name,
+                        status: conn.status,
+                        lastPing: conn.lastPing,
+                        capabilities: conn.capabilities || []
+                    }))
+            });
+        });
+        // Swarm metrics endpoint
+        this.app.get('/api/swarm/metrics', async (req, res)=>{
+            try {
+                await this.updateSwarmMetrics();
+                res.json(this.swarmMetrics);
+            } catch (error) {
+                console.error('Error fetching swarm metrics:', error);
+                res.status(500).json({
+                    error: 'Failed to fetch swarm metrics'
+                });
+            }
+        });
+        // Claude Flow commands endpoint
+        this.app.post('/api/claude-flow/command', async (req, res)=>{
+            try {
+                const { command, args = [] } = req.body;
+                const result = await this.executeClaudeFlowCommand(command, args);
+                res.json({
+                    success: true,
+                    result
+                });
+            } catch (error) {
+                console.error('Error executing Claude Flow command:', error);
+                res.status(500).json({
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                });
+            }
+        });
+        // Ruv-Swarm commands endpoint
+        this.app.post('/api/ruv-swarm/command', async (req, res)=>{
+            try {
+                const { command, args = [] } = req.body;
+                const result = await this.executeRuvSwarmCommand(command, args);
+                res.json({
+                    success: true,
+                    result
+                });
+            } catch (error) {
+                console.error('Error executing Ruv-Swarm command:', error);
+                res.status(500).json({
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                });
+            }
+        });
+        // File management endpoints
+        this.app.get('/api/files/list', async (req, res)=>{
+            try {
+                const { path: dirPath = '.' } = req.query;
+                const files = await this.listFiles(dirPath);
+                res.json({
+                    files
+                });
+            } catch (error) {
+                console.error('Error listing files:', error);
+                res.status(500).json({
+                    error: 'Failed to list files'
+                });
+            }
+        });
+        // Serve React frontend - Express v5 compatible catch-all route
+        // Use regex pattern instead of '*' wildcard for Express v5 + path-to-regexp v8 compatibility
+        this.app.get(/^\/(?!api).*/, (req, res)=>{
+            if (this.config.frontend.staticPath) {
+                const indexPath = path.join(this.config.frontend.staticPath, 'index.html');
+                res.sendFile(indexPath);
+            } else {
+                res.status(404).json({
+                    error: 'Frontend not configured'
+                });
+            }
+        });
+    }
+    setupWebSocket() {
+        this.io.on('connection', (socket)=>{
+            console.log(`Client connected: ${socket.id}`);
+            // Send initial state
+            socket.emit('mcp-status', Array.from(this.mcpConnections.entries()));
+            socket.emit('swarm-metrics', this.swarmMetrics);
+            // Handle client requests
+            socket.on('request-mcp-status', ()=>{
+                socket.emit('mcp-status', Array.from(this.mcpConnections.entries()));
+            });
+            socket.on('request-swarm-metrics', async ()=>{
+                try {
+                    await this.updateSwarmMetrics();
+                    socket.emit('swarm-metrics', this.swarmMetrics);
+                } catch (error) {
+                    socket.emit('error', {
+                        message: 'Failed to fetch swarm metrics'
+                    });
+                }
+            });
+            socket.on('execute-command', async (data)=>{
+                try {
+                    let result;
+                    if (data.service === 'claude-flow') {
+                        result = await this.executeClaudeFlowCommand(data.command, data.args || []);
+                    } else {
+                        result = await this.executeRuvSwarmCommand(data.command, data.args || []);
+                    }
+                    socket.emit('command-result', {
+                        success: true,
+                        result
+                    });
+                } catch (error) {
+                    socket.emit('command-result', {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error'
+                    });
+                }
+            });
+            socket.on('disconnect', ()=>{
+                console.log(`Client disconnected: ${socket.id}`);
+            });
+        });
+        // Broadcast updates periodically - only if there are connected clients
+        setInterval(async ()=>{
+            if (this.io.engine.clientsCount === 0) return; // Skip if no clients
+            try {
+                await this.updateSwarmMetrics();
+                await this.checkMCPConnections();
+                this.io.emit('swarm-metrics', this.swarmMetrics);
+                this.io.emit('mcp-status', Array.from(this.mcpConnections.entries()));
+            } catch (error) {
+                console.error('Error broadcasting updates:', error);
+            }
+        }, Math.max(this.config.websocket.updateInterval, 30000)); // Minimum 30s interval
+    }
+    async executeClaudeFlowCommand(command, args) {
+        const cmdString = `npx claude-flow-novice ${command} ${args.join(' ')}`;
+        console.log(`Executing Claude Flow command: ${cmdString}`);
+        try {
+            const { stdout, stderr } = await execAsync(cmdString, {
+                timeout: 30000,
+                cwd: process.cwd()
+            });
+            if (stderr && !stderr.includes('INFO') && !stderr.includes('WARN')) {
+                throw new Error(stderr);
+            }
+            return {
+                output: stdout,
+                command: cmdString
+            };
+        } catch (error) {
+            console.error(`Claude Flow command failed: ${error}`);
+            throw error;
+        }
+    }
+    async executeRuvSwarmCommand(command, args) {
+        const cmdString = `npx ruv-swarm ${command} ${args.join(' ')}`;
+        console.log(`Executing Ruv-Swarm command: ${cmdString}`);
+        try {
+            const { stdout, stderr } = await execAsync(cmdString, {
+                timeout: 30000,
+                cwd: process.cwd()
+            });
+            if (stderr && !stderr.includes('INFO') && !stderr.includes('WARN')) {
+                throw new Error(stderr);
+            }
+            return {
+                output: stdout,
+                command: cmdString
+            };
+        } catch (error) {
+            console.error(`Ruv-Swarm command failed: ${error}`);
+            throw error;
+        }
+    }
+    async updateSwarmMetrics() {
+        try {
+            // Get Claude Flow metrics
+            const cfMetrics = await this.executeClaudeFlowCommand('swarm status', []);
+            // Get Ruv-Swarm metrics if available
+            let rsMetrics;
+            try {
+                rsMetrics = await this.executeRuvSwarmCommand('status', []);
+            } catch (error) {
+                // Ruv-Swarm might not be available
+                console.log('Ruv-Swarm not available for metrics');
+            }
+            // Parse and update metrics
+            this.swarmMetrics = {
+                activeAgents: this.parseActiveAgents(cfMetrics.output),
+                totalTasks: this.parseTotalTasks(cfMetrics.output),
+                completedTasks: this.parseCompletedTasks(cfMetrics.output),
+                memoryUsage: process.memoryUsage().heapUsed / 1024 / 1024,
+                cpuUsage: process.cpuUsage().user / 1000000,
+                networkLatency: Date.now() % 100
+            };
+        } catch (error) {
+            console.error('Error updating swarm metrics:', error);
+        }
+    }
+    async checkMCPConnections() {
+        const connections = [
+            'claude-flow',
+            'ruv-swarm'
+        ];
+        for (const conn of connections){
+            try {
+                // Test connection with a simple command
+                const result = conn === 'claude-flow' ? await this.executeClaudeFlowCommand('--version', []) : await this.executeRuvSwarmCommand('--version', []);
+                this.mcpConnections.set(conn, {
+                    name: conn,
+                    status: 'connected',
+                    lastPing: new Date(),
+                    capabilities: this.parseCapabilities(result.output)
+                });
+            } catch (error) {
+                this.mcpConnections.set(conn, {
+                    name: conn,
+                    status: 'error',
+                    lastPing: new Date()
+                });
+            }
+        }
+    }
+    parseActiveAgents(output) {
+        const match = output.match(/(\d+)\s+active\s+agents?/i);
+        return match ? parseInt(match[1]) : 0;
+    }
+    parseTotalTasks(output) {
+        const match = output.match(/(\d+)\s+total\s+tasks?/i);
+        return match ? parseInt(match[1]) : 0;
+    }
+    parseCompletedTasks(output) {
+        const match = output.match(/(\d+)\s+completed\s+tasks?/i);
+        return match ? parseInt(match[1]) : 0;
+    }
+    parseCapabilities(output) {
+        // Basic capability parsing - extend as needed
+        const capabilities = [];
+        if (output.includes('swarm')) capabilities.push('swarm-coordination');
+        if (output.includes('agent')) capabilities.push('agent-management');
+        if (output.includes('task')) capabilities.push('task-orchestration');
+        return capabilities;
+    }
+    async listFiles(dirPath) {
+        try {
+            const entries = await fs.readdir(dirPath, {
+                withFileTypes: true
+            });
+            return entries.map((entry)=>({
+                    name: entry.name,
+                    type: entry.isDirectory() ? 'directory' : 'file',
+                    path: path.join(dirPath, entry.name)
+                }));
+        } catch (error) {
+            throw new Error(`Failed to list files in ${dirPath}: ${error}`);
+        }
+    }
+    async start() {
+        return new Promise((resolve, reject)=>{
+            this.server.listen(this.config.server.port, this.config.server.host, async ()=>{
+                console.log(`🚀 Claude Flow Personal Web Portal started`);
+                console.log(`📡 Server: http://${this.config.server.host}:${this.config.server.port}`);
+                console.log(`🔌 WebSocket: ws://${this.config.server.host}:${this.config.server.port}`);
+                // Initialize MCP connections
+                await this.checkMCPConnections();
+                console.log(`🔗 MCP connections initialized`);
+                resolve();
+            });
+            this.server.on('error', (error)=>{
+                console.error('Server error:', error);
+                reject(error);
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve)=>{
+            this.server.close(()=>{
+                console.log('🛑 Web Portal Server stopped');
+                resolve();
+            });
+        });
+    }
+    getApp() {
+        return this.app;
+    }
+    getServer() {
+        return this.server;
+    }
+    getIO() {
+        return this.io;
+    }
+    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, "mcpConnections", new Map());
+        _define_property(this, "swarmMetrics", {
+            activeAgents: 0,
+            totalTasks: 0,
+            completedTasks: 0,
+            memoryUsage: 0,
+            cpuUsage: 0,
+            networkLatency: 0
+        });
+        this.config = config || loadConfig();
+        this.app = express();
+        this.server = createServer(this.app);
+        this.io = new SocketIOServer(this.server, {
+            cors: {
+                origin: this.config.cors.allowedOrigins,
+                methods: [
+                    'GET',
+                    'POST'
+                ],
+                credentials: true
+            },
+            pingTimeout: 60000,
+            pingInterval: 25000
+        });
+        this.setupMiddleware();
+        this.setupRoutes();
+        this.setupWebSocket();
+    }
+}
+// Export for use as module
+export default WebPortalServer;
+// CLI entry point
+// Check if this file is being run directly (ES module compatible)
+const isMainModule = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith('portal-server.js') || process.argv[1]?.endsWith('portal-server.ts');
+if (isMainModule) {
+    const server = new WebPortalServer();
+    server.start().catch((error)=>{
+        console.error('Failed to start web portal:', error);
+        process.exit(1);
+    });
+    // Graceful shutdown
+    process.on('SIGINT', async ()=>{
+        console.log('\n🛑 Shutting down gracefully...');
+        await server.stop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async ()=>{
+        console.log('\n🛑 Shutting down gracefully...');
+        await server.stop();
+        process.exit(0);
+    });
+}