0xray 4.0.12 → 4.0.13

package/dist/mcps/boot-orchestrator.server.js

@@ -1,835 +0,0 @@
-/**
- * 0xRay Boot Orchestrator MCP Server
- *
- * Advanced initialization orchestration with dependency management and health monitoring
- */
-import { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-import { execSync } from "child_process";
-import fs from "fs";
-import path from "path";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { resolveLogDir, resolveStateDir } from "../core/config-paths.js";
-class XrayBootOrchestratorServer extends XrayKnowledgeSkillBase {
-    bootStatus;
-    // Boot sequence in dependency order
-    bootSequence = [
-        "configuration",
-        "logging",
-        "state-management",
-        "security",
-        "codex-loader",
-        "context-loader",
-        "processor-pipeline",
-        "agent-registry",
-        "orchestrator",
-        "mcp-servers",
-        "framework-hooks",
-    ];
-    constructor() {
-        super("boot-orchestrator", "3.1.0");
-        this.bootStatus = {
-            initialized: false,
-            startTime: Date.now(),
-            components: new Map(),
-            dependencies: new Map(),
-            health: new Map(),
-        };
-        // Initialize dependency map
-        this.initializeDependencies();
-        this.tools = [
-            {
-                name: "execute-boot-sequence",
-                description: "Execute the complete 0xRay boot sequence with dependency resolution",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        config: { type: "object" },
-                        skipHealthChecks: { type: "boolean", default: false },
-                        parallelInit: { type: "boolean", default: true },
-                    },
-                },
-            },
-            {
-                name: "get-boot-status",
-                description: "Get comprehensive boot orchestrator status and health",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        detailed: { type: "boolean", default: false },
-                        component: { type: "string" },
-                    },
-                },
-            },
-            {
-                name: "initialize-component",
-                description: "Initialize a specific framework component",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        component: {
-                            type: "string",
-                            enum: this.bootSequence,
-                        },
-                        force: { type: "boolean", default: false },
-                    },
-                    required: ["component"],
-                },
-            },
-            {
-                name: "validate-boot-dependencies",
-                description: "Validate all boot dependencies and prerequisites",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        fix: { type: "boolean", default: false },
-                        verbose: { type: "boolean", default: false },
-                    },
-                },
-            },
-            {
-                name: "shutdown-framework",
-                description: "Gracefully shutdown framework components",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        force: { type: "boolean", default: false },
-                        saveState: { type: "boolean", default: true },
-                    },
-                },
-            },
-        ];
-        this.setupToolHandlers();
-        void frameworkLogger.log("mcps/boot-orchestrator", "initialize", "info");
-    }
-    initializeDependencies() {
-        // Define component dependencies
-        this.bootStatus.dependencies.set("configuration", []);
-        this.bootStatus.dependencies.set("logging", ["configuration"]);
-        this.bootStatus.dependencies.set("state-management", [
-            "configuration",
-            "logging",
-        ]);
-        this.bootStatus.dependencies.set("security", ["configuration"]);
-        this.bootStatus.dependencies.set("codex-loader", [
-            "configuration",
-            "logging",
-        ]);
-        this.bootStatus.dependencies.set("context-loader", [
-            "configuration",
-            "codex-loader",
-        ]);
-        this.bootStatus.dependencies.set("processor-pipeline", [
-            "state-management",
-            "security",
-            "codex-loader",
-        ]);
-        this.bootStatus.dependencies.set("agent-registry", [
-            "configuration",
-            "state-management",
-            "processor-pipeline",
-        ]);
-        this.bootStatus.dependencies.set("orchestrator", [
-            "agent-registry",
-            "processor-pipeline",
-        ]);
-        this.bootStatus.dependencies.set("mcp-servers", [
-            "orchestrator",
-            "agent-registry",
-        ]);
-        this.bootStatus.dependencies.set("framework-hooks", [
-            "mcp-servers",
-            "orchestrator",
-        ]);
-    }
-    setupToolHandlers() {
-        this.setupListToolsHandler();
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "execute-boot-sequence":
-                    return await this.handleExecuteBootSequence(args);
-                case "get-boot-status":
-                    return await this.handleGetBootStatus(args);
-                case "initialize-component":
-                    return await this.handleInitializeComponent(args);
-                case "validate-boot-dependencies":
-                    return await this.handleValidateBootDependencies(args);
-                case "shutdown-framework":
-                    return await this.handleShutdownFramework(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
-    }
-    async handleExecuteBootSequence(args) {
-        const config = args.config || {};
-        const skipHealthChecks = args.skipHealthChecks || false;
-        const parallelInit = args.parallelInit !== false;
-        frameworkLogger.log("mcp-boot-orchestrator", "execute-boot-sequence", "info", {
-            skipHealthChecks,
-            parallelInit,
-        });
-        const results = {
-            success: true,
-            initializedComponents: [],
-            failedComponents: [],
-            duration: 0,
-            errors: [],
-            warnings: [],
-        };
-        const startTime = Date.now();
-        try {
-            // Validate prerequisites
-            const validationResults = await this.validatePrerequisites();
-            if (!validationResults.valid) {
-                results.success = false;
-                results.errors.push(...validationResults.errors);
-                return this.formatBootResults(results);
-            }
-            // Execute boot sequence
-            if (parallelInit) {
-                await this.executeParallelBoot(skipHealthChecks, results);
-            }
-            else {
-                await this.executeSequentialBoot(skipHealthChecks, results);
-            }
-            results.duration = Date.now() - startTime;
-            this.bootStatus.initialized = results.success;
-            return this.formatBootResults(results);
-        }
-        catch (error) {
-            results.success = false;
-            results.duration = Date.now() - startTime;
-            results.errors.push(`Boot sequence failed: ${error instanceof Error ? error.message : String(error)}`);
-            return this.formatBootResults(results);
-        }
-    }
-    async handleGetBootStatus(args) {
-        const detailed = args.detailed || false;
-        const component = args.component;
-        frameworkLogger.log("mcp-boot-orchestrator", "get-boot-status", "info", { detailed, component });
-        try {
-            if (component) {
-                // Get specific component status
-                const status = await this.getComponentStatus(component);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `📊 Component Status: ${component}\n${this.formatComponentStatus(component, status, detailed)}`,
-                        },
-                    ],
-                };
-            }
-            else {
-                // Get overall boot status
-                const status = this.getOverallBootStatus();
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `📊 Framework Boot Status\n${this.formatOverallStatus(status, detailed)}`,
-                        },
-                    ],
-                };
-            }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `❌ Status check failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async handleInitializeComponent(args) {
-        const component = args.component;
-        const force = args.force || false;
-        frameworkLogger.log("mcp-boot-orchestrator", "initialize-component", "info", { component, force });
-        try {
-            if (!this.bootSequence.includes(component)) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `❌ Unknown component: ${component}\nAvailable: ${this.bootSequence.join(", ")}`,
-                        },
-                    ],
-                };
-            }
-            // Check if already initialized
-            if (this.bootStatus.components.has(component) && !force) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `⚠️ Component already initialized: ${component}\nUse force=true to re-initialize`,
-                        },
-                    ],
-                };
-            }
-            // Check dependencies
-            const deps = this.bootStatus.dependencies.get(component) || [];
-            for (const dep of deps) {
-                if (!this.bootStatus.components.has(dep)) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `❌ Dependency not met: ${component} requires ${dep}\nInitialize dependencies first`,
-                            },
-                        ],
-                    };
-                }
-            }
-            // Initialize component
-            const result = await this.initializeComponent(component);
-            this.bootStatus.components.set(component, result);
-            this.bootStatus.health.set(component, result.success);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `🔧 Component Initialized: ${component}\n**Status:** ${result.success ? "✅ SUCCESS" : "❌ FAILED"}\n**Duration:** ${result.duration}ms\n${result.message || ""}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `❌ Component initialization failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async handleValidateBootDependencies(args) {
-        const fix = args.fix || false;
-        const verbose = args.verbose || false;
-        frameworkLogger.log("mcp-boot-orchestrator", "validate-boot-dependencies", "info", { fix, verbose });
-        try {
-            const results = await this.validateAllDependencies(fix, verbose);
-            const response = `🔍 Dependency Validation Results
-
-**Total Components:** ${results.total}
-**Valid Dependencies:** ${results.valid}
-**Missing Dependencies:** ${results.missing}
-**Circular Dependencies:** ${results.circular}
-
-${results.issues.length > 0 ? `**Issues Found:**\n${results.issues.map((issue) => `• ${issue}`).join("\n")}\n` : ""}
-${results.fixes.length > 0 ? `**Fixes Applied:**\n${results.fixes.map((fix) => `• ${fix}`).join("\n")}\n` : ""}
-
-**Status:** ${results.valid === results.total ? "✅ ALL VALID" : "❌ ISSUES DETECTED"}`;
-            return {
-                content: [{ type: "text", text: response }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `❌ Dependency validation failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async handleShutdownFramework(args) {
-        const force = args.force || false;
-        const saveState = args.saveState !== false;
-        frameworkLogger.log("mcps/boot-orchestrator", "shutdown", "info", { force, saveState });
-        try {
-            const results = await this.executeShutdownSequence(force, saveState);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `🛑 Framework Shutdown Complete
-
-**Components Shut Down:** ${results.shutDown}
-**State Saved:** ${results.stateSaved}
-**Errors:** ${results.errors.length}
-**Duration:** ${results.duration}ms
-
-${results.errors.length > 0 ? `**Errors:**\n${results.errors.map((e) => `• ${e}`).join("\n")}` : ""}
-
-**Status:** ${results.success ? "✅ SHUTDOWN COMPLETE" : "❌ SHUTDOWN ISSUES"}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `❌ Shutdown failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async validatePrerequisites() {
-        const errors = [];
-        // Check Node.js version
-        try {
-            const nodeVersionOutput = execSync("node --version", { encoding: "utf8" })?.toString().trim() ||
-                "";
-            const nodeVersion = nodeVersionOutput || "v1.2.0";
-            const versionParts = nodeVersion.split(".");
-            const majorVersion = versionParts.length > 0 && versionParts[0]
-                ? parseInt(versionParts[0].substring(1))
-                : 0;
-            if (majorVersion < 18) {
-                errors.push(`Node.js version ${nodeVersion} is too old. Requires 18+`);
-            }
-        }
-        catch (error) {
-            errors.push("Cannot determine Node.js version");
-        }
-        // Check required directories
-        const requiredDirs = ["src", "src/agents", "src/mcps"];
-        for (const dir of requiredDirs) {
-            if (!fs.existsSync(dir)) {
-                errors.push(`Required directory missing: ${dir}`);
-            }
-        }
-        // Check package.json
-        if (!fs.existsSync("package.json")) {
-            errors.push("package.json not found");
-        }
-        return {
-            valid: errors.length === 0,
-            errors,
-        };
-    }
-    async executeParallelBoot(skipHealthChecks, results) {
-        const componentPromises = this.bootSequence.map((component) => this.initializeComponent(component, skipHealthChecks));
-        const componentResults = await Promise.allSettled(componentPromises);
-        for (let i = 0; i < componentResults.length; i++) {
-            const component = this.bootSequence[i];
-            if (!component)
-                continue;
-            const result = componentResults[i];
-            if (!result)
-                continue;
-            if (result.status === "fulfilled") {
-                const fulfilledResult = result;
-                if (fulfilledResult.value.success) {
-                    results.initializedComponents.push(component);
-                    this.bootStatus.components.set(component, fulfilledResult.value);
-                    this.bootStatus.health.set(component, true);
-                }
-                else {
-                    results.failedComponents.push(component);
-                    results.errors.push(`${component}: ${fulfilledResult.value.error || "Unknown error"}`);
-                }
-            }
-            else {
-                results.failedComponents.push(component);
-                results.errors.push(`${component}: ${result.reason}`);
-            }
-        }
-        results.success = results.failedComponents.length === 0;
-    }
-    async executeSequentialBoot(skipHealthChecks, results) {
-        for (const component of this.bootSequence) {
-            try {
-                const result = await this.initializeComponent(component, skipHealthChecks);
-                if (result.success) {
-                    results.initializedComponents.push(component);
-                    this.bootStatus.components.set(component, result);
-                    this.bootStatus.health.set(component, true);
-                }
-                else {
-                    results.failedComponents.push(component);
-                    results.errors.push(`${component}: ${result.error}`);
-                    break; // Stop on first failure in sequential mode
-                }
-            }
-            catch (error) {
-                results.failedComponents.push(component);
-                results.errors.push(`${component}: ${error instanceof Error ? error.message : String(error)}`);
-                break;
-            }
-        }
-        results.success = results.failedComponents.length === 0;
-    }
-    async initializeComponent(component, skipHealthChecks = false) {
-        const startTime = Date.now();
-        try {
-            switch (component) {
-                case "configuration":
-                    return await this.initConfiguration();
-                case "logging":
-                    return await this.initLogging();
-                case "state-management":
-                    return await this.initStateManagement();
-                case "security":
-                    return await this.initSecurity();
-                case "codex-loader":
-                    return await this.initCodexLoader();
-                case "context-loader":
-                    return await this.initContextLoader();
-                case "processor-pipeline":
-                    return await this.initProcessorPipeline();
-                case "agent-registry":
-                    return await this.initAgentRegistry();
-                case "orchestrator":
-                    return await this.initOrchestrator();
-                case "mcp-servers":
-                    return await this.initMCPServers();
-                case "framework-hooks":
-                    return await this.initFrameworkHooks();
-                default:
-                    throw new Error(`Unknown component: ${component}`);
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                duration: Date.now() - startTime,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async initConfiguration() {
-        return {
-            success: true,
-            duration: 10,
-            message: "Configuration initialized",
-        };
-    }
-    async initLogging() {
-        // Initialize logging system
-        const logDir = resolveLogDir();
-        if (!fs.existsSync(logDir)) {
-            fs.mkdirSync(logDir, { recursive: true });
-        }
-        return {
-            success: true,
-            duration: 5,
-            message: "Logging system initialized",
-        };
-    }
-    async initStateManagement() {
-        // Validate state management setup
-        const stateDir = resolveStateDir();
-        if (!fs.existsSync(stateDir)) {
-            fs.mkdirSync(stateDir, { recursive: true });
-        }
-        return {
-            success: true,
-            duration: 8,
-            message: "State management initialized",
-        };
-    }
-    async initSecurity() {
-        // Basic security initialization
-        return {
-            success: true,
-            duration: 3,
-            message: "Security framework initialized",
-        };
-    }
-    async initCodexLoader() {
-        return {
-            success: true,
-            duration: 12,
-            message: "Codex loader initialized",
-        };
-    }
-    async initContextLoader() {
-        return {
-            success: true,
-            duration: 8,
-            message: "Context loader initialized",
-        };
-    }
-    async initProcessorPipeline() {
-        // Validate processor pipeline
-        return {
-            success: true,
-            duration: 15,
-            message: "Processor pipeline initialized",
-        };
-    }
-    async initAgentRegistry() {
-        // Check agent files exist
-        const agentCount = this.countAgentFiles();
-        if (agentCount < 5) {
-            throw new Error(`Insufficient agents found: ${agentCount}`);
-        }
-        return {
-            success: true,
-            duration: 10,
-            message: `Agent registry initialized with ${agentCount} agents`,
-        };
-    }
-    async initOrchestrator() {
-        // Validate orchestrator setup
-        return {
-            success: true,
-            duration: 20,
-            message: "Orchestrator initialized",
-        };
-    }
-    async initMCPServers() {
-        // Check MCP servers
-        const mcpCount = this.countMCPFiles();
-        if (mcpCount < 3) {
-            throw new Error(`Insufficient MCP servers found: ${mcpCount}`);
-        }
-        return {
-            success: true,
-            duration: 15,
-            message: `MCP servers initialized (${mcpCount} servers)`,
-        };
-    }
-    async initFrameworkHooks() {
-        // Initialize framework hooks
-        return {
-            success: true,
-            duration: 5,
-            message: "Framework hooks initialized",
-        };
-    }
-    countAgentFiles() {
-        try {
-            const files = fs.readdirSync("src/agents");
-            return files.filter((f) => f.endsWith(".ts") && f !== "types.ts" && f !== "index.ts").length;
-        }
-        catch (error) {
-            return 0;
-        }
-    }
-    countMCPFiles() {
-        try {
-            const files = fs.readdirSync("src/mcps");
-            return files.filter((f) => f.endsWith(".server.ts")).length;
-        }
-        catch (error) {
-            return 0;
-        }
-    }
-    async getComponentStatus(component) {
-        const initialized = this.bootStatus.components.has(component);
-        const healthy = this.bootStatus.health.get(component) || false;
-        const info = this.bootStatus.components.get(component);
-        return {
-            initialized,
-            healthy,
-            info,
-            dependencies: this.bootStatus.dependencies.get(component) || [],
-        };
-    }
-    getOverallBootStatus() {
-        const totalComponents = this.bootSequence.length;
-        const initializedComponents = Array.from(this.bootStatus.components.keys());
-        const healthyComponents = Array.from(this.bootStatus.health.values()).filter((h) => h).length;
-        return {
-            initialized: this.bootStatus.initialized,
-            uptime: Date.now() - this.bootStatus.startTime,
-            totalComponents,
-            initializedComponents: initializedComponents.length,
-            healthyComponents,
-            failedComponents: initializedComponents.length - healthyComponents,
-        };
-    }
-    async validateAllDependencies(fix, verbose) {
-        const results = {
-            total: this.bootSequence.length,
-            valid: 0,
-            missing: 0,
-            circular: 0,
-            issues: [],
-            fixes: [],
-        };
-        // Check for missing dependencies
-        for (const component of this.bootSequence) {
-            const deps = this.bootStatus.dependencies.get(component) || [];
-            const missingDeps = deps.filter((dep) => !this.checkComponentExists(dep));
-            if (missingDeps.length > 0) {
-                results.missing++;
-                results.issues.push(`${component} missing dependencies: ${missingDeps.join(", ")}`);
-            }
-            else {
-                results.valid++;
-            }
-        }
-        // Check for circular dependencies (simplified)
-        const circularDeps = this.detectCircularDependencies();
-        if (circularDeps.length > 0) {
-            results.circular = circularDeps.length;
-            results.issues.push(`Circular dependencies detected: ${circularDeps.join(", ")}`);
-        }
-        // Apply fixes if requested
-        if (fix && results.issues.length > 0) {
-            results.fixes = await this.applyDependencyFixes(results.issues);
-        }
-        return results;
-    }
-    checkComponentExists(component) {
-        // Simplified check - in real implementation this would be more thorough
-        switch (component) {
-            case "configuration":
-                return fs.existsSync("opencode.json");
-            case "logging":
-                return fs.existsSync("src/framework-logger.ts");
-            case "state-management":
-                return fs.existsSync("src/state/state-manager.ts");
-            case "security":
-                return true;
-            case "codex-loader":
-                return true;
-            case "context-loader":
-                return true;
-            case "processor-pipeline":
-                return fs.existsSync("src/processors/processor-manager.ts");
-            case "agent-registry":
-                return fs.existsSync("src/agents");
-            case "orchestrator":
-                return fs.existsSync("src/delegation/agent-delegator.ts");
-            case "mcp-servers":
-                return fs.existsSync("src/mcps");
-            case "framework-hooks":
-                return fs.existsSync("src/core/xray-activation.ts");
-            default:
-                return false;
-        }
-    }
-    detectCircularDependencies() {
-        // Simplified circular dependency detection
-        const circular = [];
-        for (const [component, deps] of this.bootStatus.dependencies) {
-            for (const dep of deps) {
-                const depDeps = this.bootStatus.dependencies.get(dep) || [];
-                if (depDeps.includes(component)) {
-                    circular.push(`${component} ↔ ${dep}`);
-                }
-            }
-        }
-        return [...new Set(circular)]; // Remove duplicates
-    }
-    async applyDependencyFixes(issues) {
-        const fixes = [];
-        // Simplified fix application
-        for (const issue of issues) {
-            if (issue.includes("missing dependencies")) {
-                fixes.push("Dependency validation completed - manual fixes may be required");
-            }
-        }
-        return fixes;
-    }
-    async executeShutdownSequence(force, saveState) {
-        const results = {
-            success: true,
-            shutDown: 0,
-            stateSaved: saveState,
-            errors: [],
-            duration: 0,
-        };
-        const startTime = Date.now();
-        try {
-            // Shutdown in reverse order
-            const reverseSequence = [...this.bootSequence].reverse();
-            for (const component of reverseSequence) {
-                try {
-                    await this.shutdownComponent(component, force);
-                    results.shutDown++;
-                }
-                catch (error) {
-                    results.errors.push(`${component}: ${error instanceof Error ? error.message : String(error)}`);
-                    if (!force) {
-                        results.success = false;
-                    }
-                }
-            }
-            // Save state if requested
-            if (saveState) {
-                await this.saveShutdownState();
-            }
-        }
-        catch (error) {
-            results.success = false;
-            results.errors.push(`Shutdown error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        results.duration = Date.now() - startTime;
-        return results;
-    }
-    async shutdownComponent(component, force) {
-        // Simplified shutdown logic
-        frameworkLogger.log("mcps/boot-orchestrator", "shutdown-component", "info", { component });
-        // In real implementation, this would properly shut down each component
-        await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    async saveShutdownState() {
-        // Save shutdown state
-        const shutdownState = {
-            timestamp: Date.now(),
-            components: Array.from(this.bootStatus.components.keys()),
-            health: Object.fromEntries(this.bootStatus.health),
-        };
-        const stateFile = path.join(".opencode", "state", "shutdown-state.json");
-        fs.writeFileSync(stateFile, JSON.stringify(shutdownState, null, 2));
-    }
-    formatBootResults(results) {
-        const response = `🚀 Boot Sequence Results
-
-**Success:** ${results.success ? "✅ COMPLETE" : "❌ FAILED"}
-**Duration:** ${results.duration}ms
-**Components Initialized:** ${results.initializedComponents.length}/${this.bootSequence.length}
-**Components Failed:** ${results.failedComponents.length}
-
-**Initialized Components:**
-${results.initializedComponents.map((c) => `• ✅ ${c}`).join("\n")}
-
-${results.failedComponents.length > 0 ? `**Failed Components:**\n${results.failedComponents.map((c) => `• ❌ ${c}`).join("\n")}\n` : ""}
-${results.errors.length > 0 ? `**Errors:**\n${results.errors.map((e) => `• 💥 ${e}`).join("\n")}\n` : ""}
-${results.warnings.length > 0 ? `**Warnings:**\n${results.warnings.map((w) => `• ⚠️ ${w}`).join("\n")}\n` : ""}
-
-**Framework Status:** ${results.success ? "🟢 OPERATIONAL" : "🔴 INITIALIZATION FAILED"}`;
-        return {
-            content: [{ type: "text", text: response }],
-        };
-    }
-    formatComponentStatus(component, status, detailed) {
-        let response = `**Component:** ${component}
-**Initialized:** ${status.initialized ? "✅ Yes" : "❌ No"}
-**Healthy:** ${status.healthy ? "✅ Yes" : "❌ No"}
-**Dependencies:** ${status.dependencies.join(", ") || "None"}`;
-        if (detailed && status.info) {
-            response += `\n**Info:** ${JSON.stringify(status.info, null, 2)}`;
-        }
-        return response;
-    }
-    formatOverallStatus(status, detailed) {
-        let response = `**Initialized:** ${status.initialized ? "✅ Yes" : "❌ No"}
-**Uptime:** ${Math.round(status.uptime / 1000)}s
-**Components:** ${status.initializedComponents}/${status.totalComponents} initialized
-**Healthy:** ${status.healthyComponents}/${status.initializedComponents} healthy
-**Failed:** ${status.failedComponents} failed`;
-        if (detailed) {
-            response += `\n\n**Component Details:**`;
-            for (const component of this.bootSequence) {
-                const compStatus = this.bootStatus.health.get(component);
-                response += `\n• ${component}: ${compStatus ? "✅" : "❌"}`;
-            }
-        }
-        return response;
-    }
-}
-// Start the server if run directly
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new XrayBootOrchestratorServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/boot-orchestrator", "run", "error", { error: String(error) }));
-}
-export { XrayBootOrchestratorServer };