0xray 2.0.0

package/dist/mcps/orchestrator/handlers/status-handler.js

@@ -0,0 +1,232 @@
+/**
+ * Status Handler
+ *
+ * Handles orchestration status requests
+ */
+import { frameworkLogger } from '../../../core/framework-logger.js';
+/**
+ * Status Handler
+ * Processes get-orchestration-status requests
+ */
+export class StatusHandler {
+    /**
+     * Handle get-orchestration-status request
+     */
+    async handleGetOrchestrationStatus(args, deps) {
+        const { sessionId, detailed = false } = args;
+        await frameworkLogger.log('orchestrator.server', 'get-status-start', 'info', { sessionId, detailed });
+        try {
+            let status;
+            if (sessionId) {
+                status = deps.activeTasks.get(sessionId);
+                if (!status) {
+                    // Check history
+                    const historyItem = deps.taskHistory.find((h) => h.sessionId === sessionId);
+                    if (historyItem) {
+                        status = { completed: true, ...historyItem.result };
+                    }
+                    else {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `❌ Session not found: ${sessionId}`,
+                                },
+                            ],
+                        };
+                    }
+                }
+            }
+            else {
+                // Overall status
+                status = this.getOverallStatus(deps);
+            }
+            const response = this.formatStatusResponse(status, detailed);
+            return { content: [{ type: 'text', text: response }] };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Status check failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Handle cancel-orchestration request
+     */
+    async handleCancelOrchestration(args, deps) {
+        const { sessionId, taskId, force = false } = args;
+        await frameworkLogger.log('orchestrator.server', 'cancel-orchestration-start', 'info', { sessionId, taskId, force });
+        try {
+            if (!sessionId) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '❌ sessionId is required for cancellation',
+                        },
+                    ],
+                };
+            }
+            // Check if session exists
+            const existingTask = deps.activeTasks.get(sessionId);
+            if (!existingTask) {
+                // Check history
+                const historyItem = deps.taskHistory.find((h) => h.sessionId === sessionId);
+                if (historyItem) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Session already completed: ${sessionId}`,
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ Session not found: ${sessionId}`,
+                        },
+                    ],
+                };
+            }
+            // Cancel the session
+            deps.activeTasks.delete(sessionId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Orchestration cancelled: ${sessionId}${taskId ? ` (task: ${taskId})` : ''}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Cancellation failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Handle optimize-orchestration request
+     */
+    async handleOptimizeOrchestration(args) {
+        const { history = true, recommendations = true } = args;
+        await frameworkLogger.log('orchestrator.server', 'optimize-orchestration-start', 'info', { history, recommendations });
+        try {
+            const optimizations = [];
+            if (recommendations) {
+                optimizations.push('Consider using "optimized" execution mode for most workflows');
+                optimizations.push('Batch similar tasks together for better agent utilization');
+                optimizations.push('Monitor agent utilization and adjust concurrent task limits');
+            }
+            if (history) {
+                optimizations.push('Review historical data to identify recurring patterns');
+                optimizations.push('Use complexity analysis to pre-plan task distribution');
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `🔧 Orchestration Optimization Results
+
+**Optimizations Available:**
+${optimizations.map((o) => `• ${o}`).join('\n')}
+
+**Current Best Practices:**
+• Use "optimized" mode for mixed task types
+• Set appropriate timeouts based on task complexity
+• Monitor bottleneck agents and redistribute load
+• Leverage task dependencies for correct execution order`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Optimization failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Get overall orchestration status
+     */
+    getOverallStatus(deps) {
+        const agentUtilization = {};
+        // Aggregate from active tasks
+        for (const [, task] of deps.activeTasks) {
+            const taskAny = task;
+            if (taskAny.agentUtilization) {
+                const util = taskAny.agentUtilization;
+                for (const [agent, count] of Object.entries(util)) {
+                    agentUtilization[agent] = (agentUtilization[agent] || 0) + count;
+                }
+            }
+        }
+        // Get recent sessions from history
+        const recentSessions = deps.taskHistory
+            .slice(-10)
+            .map((h) => ({
+            sessionId: h.sessionId,
+            status: 'completed',
+            tasks: h.tasks,
+            duration: h.result.duration,
+        }));
+        return {
+            activeSessions: deps.activeTasks.size,
+            totalTasks: deps.taskHistory.reduce((sum, h) => sum + h.tasks, 0),
+            agentUtilization,
+            recentSessions,
+        };
+    }
+    /**
+     * Format status response
+     */
+    formatStatusResponse(status, detailed) {
+        const statusAny = status;
+        // Check if it's a completed session
+        if (statusAny.completed) {
+            const result = statusAny;
+            return `📊 Session Status: COMPLETED
+
+**Success:** ${result.success ? '✅ Yes' : '❌ No'}
+**Duration:** ${result.duration}ms
+**Tasks:** ${result.completedTasks + result.failedTasks} (${result.completedTasks} ✅, ${result.failedTasks} ❌)`;
+        }
+        // Overall status
+        const orchStatus = status;
+        let response = `📊 Orchestration Status
+
+**Active Sessions:** ${orchStatus.activeSessions}
+**Total Tasks Executed:** ${orchStatus.totalTasks}`;
+        if (Object.keys(orchStatus.agentUtilization).length > 0) {
+            response += `\n\n**Agent Utilization:**`;
+            for (const [agent, count] of Object.entries(orchStatus.agentUtilization)) {
+                response += `\n• ${agent}: ${count} tasks`;
+            }
+        }
+        if (detailed && orchStatus.recentSessions.length > 0) {
+            response += `\n\n**Recent Sessions:**`;
+            for (const session of orchStatus.recentSessions) {
+                response += `\n• ${session.sessionId}: ${session.tasks} tasks, ${session.duration}ms`;
+            }
+        }
+        return response;
+    }
+}

package/dist/mcps/orchestrator/handlers/task-handler.js

@@ -0,0 +1,197 @@
+/**
+ * Task Handler
+ *
+ * Handles task orchestration requests
+ */
+import { frameworkLogger } from '../../../core/framework-logger.js';
+import { getExecutionPlanner } from '../execution/execution-planner.js';
+import { mcpClientManager } from '../../../mcps/mcp-client.js';
+/**
+ * Task Handler
+ * Processes orchestrate-task requests
+ */
+export class TaskHandler {
+    planner = getExecutionPlanner();
+    /**
+     * Handle orchestrate-task request
+     */
+    async handleOrchestrateTask(args, deps) {
+        const { description, tasks = [], sessionId = `session_${Date.now()}`, executionMode = 'optimized', timeout = 300000 } = args;
+        await frameworkLogger.log('orchestrator.server', 'orchestrate-task-start', 'info', { description, taskCount: tasks.length, sessionId, executionMode });
+        const orchestrationResult = {
+            sessionId,
+            success: false,
+            completedTasks: 0,
+            failedTasks: 0,
+            duration: 0,
+            agentUtilization: {},
+            bottlenecks: [],
+            recommendations: [],
+        };
+        const startTime = Date.now();
+        try {
+            // Validate tasks
+            const validation = this.planner.validateTasks(tasks);
+            if (!validation.valid) {
+                throw new Error(`Task validation failed: ${validation.errors.join(', ')}`);
+            }
+            // Analyze complexity and create execution plan
+            const executionPlan = await this.planner.createExecutionPlan(tasks, executionMode);
+            // Execute orchestration (simulated for MCP server)
+            const results = await this.executePlan(executionPlan, sessionId, timeout);
+            // Update result
+            orchestrationResult.success = results.success;
+            orchestrationResult.completedTasks = results.completedTasks;
+            orchestrationResult.failedTasks = results.failedTasks;
+            orchestrationResult.agentUtilization = results.agentUtilization;
+            orchestrationResult.bottlenecks = results.bottlenecks;
+            orchestrationResult.recommendations = results.recommendations;
+            if (results.agentOutputs) {
+                orchestrationResult.agentOutputs = results.agentOutputs;
+            }
+            // Store in history
+            deps.taskHistory.push({
+                sessionId,
+                description,
+                tasks: tasks.length,
+                result: orchestrationResult,
+                timestamp: new Date().toISOString(),
+            });
+            // Store in active tasks
+            deps.activeTasks.set(sessionId, { status: 'completed', ...orchestrationResult });
+        }
+        catch (error) {
+            orchestrationResult.recommendations.push(`Orchestration error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        orchestrationResult.duration = Date.now() - startTime;
+        const response = this.formatOrchestrationResponse(description, orchestrationResult, executionMode);
+        return { content: [{ type: 'text', text: response }] };
+    }
+    /**
+     * Execute the orchestration plan.
+     * For known MCP skill servers (code-review, security-audit, researcher, etc.),
+     * we actually call the target tool. For other agents we record the assignment.
+     */
+    async executePlan(plan, sessionId, _timeout) {
+        const agentUtilization = {};
+        let completedTasks = 0;
+        let failedTasks = 0;
+        const agentOutputs = {};
+        const skillServers = new Set([
+            'code-review', 'code-reviewer',
+            'security-audit', 'security-auditor',
+            'researcher',
+            'performance-optimization',
+            'testing-strategy', 'testing-lead',
+            'bug-triage-specialist',
+            'refactorer', 'refactoring-strategies',
+            'architect', 'architecture-patterns'
+        ]);
+        for (const [agent, tasks] of plan.agentAssignments) {
+            agentUtilization[agent] = tasks.length;
+            if (skillServers.has(agent)) {
+                for (const task of tasks) {
+                    try {
+                        const toolName = this.mapAgentToTool(agent);
+                        const result = await mcpClientManager.callServerTool(agent, toolName, {
+                            description: task.description,
+                            type: task.type,
+                            priority: task.priority,
+                        });
+                        const outputText = this.extractTextFromMcpResult(result);
+                        agentOutputs[`${agent}:${task.id}`] = outputText;
+                        completedTasks++;
+                    }
+                    catch (err) {
+                        failedTasks++;
+                        agentOutputs[`${agent}:${task.id}`] = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                        frameworkLogger.log('orchestrator.task-handler', 'task-execution-failed', 'warning', {
+                            agent,
+                            taskId: task.id,
+                            error: String(err),
+                        });
+                    }
+                }
+            }
+            else {
+                // For non-MCP agents we still count them as "assigned" (they will be handled by the caller or legacy path)
+                completedTasks += tasks.length;
+            }
+        }
+        const recommendations = [];
+        const bottlenecks = [];
+        if (plan.agentAssignments.size > 5) {
+            recommendations.push('Consider reducing the number of agents for better coordination');
+        }
+        for (const [agent, tasks] of plan.agentAssignments) {
+            if (tasks.length > 3) {
+                bottlenecks.push(`${agent} is handling ${tasks.length} tasks - may be overloaded`);
+            }
+        }
+        return {
+            success: failedTasks === 0,
+            completedTasks,
+            failedTasks,
+            agentUtilization,
+            bottlenecks,
+            recommendations,
+            agentOutputs,
+        };
+    }
+    mapAgentToTool(agent) {
+        const map = {
+            // Servers that have analyze_proposal
+            'code-review': 'analyze_proposal',
+            'security-audit': 'analyze_proposal',
+            'researcher': 'analyze_proposal',
+            'bug-triage-specialist': 'analyze_proposal',
+            // Legacy aliases that should resolve to the above
+            'code-reviewer': 'analyze_proposal',
+            'security-auditor': 'analyze_proposal',
+            'refactorer': 'analyze_proposal',
+            'architect': 'analyze_proposal',
+            'architecture-patterns': 'analyze_proposal',
+            // Implementation / apply focused tools
+            'refactoring-strategies': 'suggest_refactor',
+            'testing-strategy': 'analyze_test_coverage',
+            'testing-lead': 'analyze_test_coverage',
+        };
+        return map[agent] || 'analyze_proposal';
+    }
+    extractTextFromMcpResult(result) {
+        const content = result?.content;
+        if (Array.isArray(content)) {
+            return content.map((c) => c.text ?? '').join('\n');
+        }
+        return JSON.stringify(result);
+    }
+    /**
+     * Format orchestration response
+     */
+    formatOrchestrationResponse(description, result, executionMode) {
+        return `🎯 Orchestration Complete: "${description}"
+
+**Session ID:** ${result.sessionId}
+**Success:** ${result.success ? '✅ COMPLETED' : '❌ FAILED'}
+**Duration:** ${result.duration}ms
+**Tasks:** ${result.completedTasks + result.failedTasks} total
+  - ✅ Completed: ${result.completedTasks}
+  - ❌ Failed: ${result.failedTasks}
+
+**Agent Utilization:**
+${Object.entries(result.agentUtilization)
+            .map(([agent, count]) => `• ${agent}: ${count} tasks`)
+            .join('\n')}
+
+${result.bottlenecks.length > 0 ? `**Bottlenecks Detected:**\n${result.bottlenecks.map((b) => `• 🚧 ${b}`).join('\n')}\n` : ''}
+**Recommendations:**
+${result.recommendations.length > 0 ? result.recommendations.map((r) => `• 💡 ${r}`).join('\n') : 'No recommendations'}
+
+**Execution Mode:** ${executionMode}
+**Status:** ${result.success ? '🟢 SUCCESS' : '🔴 ISSUES DETECTED'}
+
+${result.agentOutputs && Object.keys(result.agentOutputs).length > 0
+            ? `**Agent Outputs (real MCP responses):**\n${Object.entries(result.agentOutputs).map(([k, v]) => `• ${k}: ${v.substring(0, 200)}${v.length > 200 ? '...' : ''}`).join('\n')}\n`
+            : ''}`;
+    }
+}