0xray 3.1.0 → 3.2.0

package/src/mcps/boot-orchestrator.server.ts

@@ -4,13 +4,8 @@
  * Advanced initialization orchestration with dependency management and health monitoring
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolRequest,
-} from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, type CallToolRequest } 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";
@@ -92,8 +87,7 @@ interface ShutdownFrameworkArgs {
   saveState?: boolean;
 }
 
-class XrayBootOrchestratorServer {
-  private server: Server;
+class XrayBootOrchestratorServer extends XrayKnowledgeSkillBase {
   private bootStatus: {
     initialized: boolean;
     startTime: number;
@@ -118,16 +112,7 @@ class XrayBootOrchestratorServer {
   ];
 
   constructor() {
-    this.server = new Server(
-      {
-        name: "boot-orchestrator", version: "1.22.67",
-      },
-      {
-        capabilities: {
-          tools: {},
-        },
-      },
-    );
+    super("boot-orchestrator", "3.1.0");
 
     this.bootStatus = {
       initialized: false,
@@ -140,6 +125,71 @@ class XrayBootOrchestratorServer {
     // 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");
   }
@@ -185,78 +235,8 @@ class XrayBootOrchestratorServer {
     ]);
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        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 },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
+  override setupToolHandlers(): void {
+    this.setupListToolsHandler();
     this.server.setRequestHandler(
       CallToolRequestSchema,
       async (request: CallToolRequest) => {
@@ -1066,15 +1046,10 @@ ${results.warnings.length > 0 ? `**Warnings:**\n${results.warnings.map((w: strin
     return response;
   }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    frameworkLogger.log("mcps/boot-orchestrator", "start", "success");
-  }
 }
 
 // Start the server if run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+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) }));
 }

package/src/mcps/config/__tests__/config-loader.test.ts

@@ -17,25 +17,19 @@ describe('ConfigLoader', () => {
 
   beforeEach(() => {
     loader = new ConfigLoader();
+    // Clear paths so tests don't pick up the real .mcp.json
+    loader.clearConfigPaths();
     // Clean up any existing test files
-    if (fs.existsSync(testConfigPath)) {
-      fs.unlinkSync(testConfigPath);
-    }
-    if (fs.existsSync(testConfigPath2)) {
-      fs.unlinkSync(testConfigPath2);
-    }
-    if (fs.existsSync(testDir)) {
-      fs.rmdirSync(testDir);
+    for (const p of [testConfigPath, testConfigPath2]) {
+      if (fs.existsSync(p)) fs.unlinkSync(p);
     }
+    if (fs.existsSync(testDir)) fs.rmdirSync(testDir);
   });
 
   afterEach(() => {
     // Clean up test files
-    if (fs.existsSync(testConfigPath)) {
-      fs.unlinkSync(testConfigPath);
-    }
-    if (fs.existsSync(testConfigPath2)) {
-      fs.unlinkSync(testConfigPath2);
+    for (const p of [testConfigPath, testConfigPath2]) {
+      if (fs.existsSync(p)) fs.unlinkSync(p);
     }
     if (fs.existsSync(testDir)) {
       fs.rmdirSync(testDir);
@@ -163,20 +157,24 @@ describe('ConfigLoader', () => {
   });
 
   describe('getConfigPaths', () => {
-    it('should return default paths', () => {
-      const paths = loader.getConfigPaths();
-      expect(paths).toContain('.mcp.json');
-      expect(paths).toContain('.opencode/mcp.json');
-      expect(paths).toContain('mcp.config.json');
-    });
-
     it('should return added paths', () => {
+      loader.addConfigPath('.mcp.json');
       loader.addConfigPath('custom/path.json');
       const paths = loader.getConfigPaths();
+      expect(paths).toContain('.mcp.json');
       expect(paths).toContain('custom/path.json');
     });
 
+    it('should return default paths via new instance', () => {
+      const fresh = new ConfigLoader();
+      const paths = fresh.getConfigPaths();
+      expect(paths).toContain('.mcp.json');
+      expect(paths).toContain('.opencode/mcp.json');
+      expect(paths).toContain('mcp.config.json');
+    });
+
     it('should return copy of paths array', () => {
+      loader.addConfigPath('.mcp.json');
       const paths = loader.getConfigPaths();
       paths.push('modified');
       const paths2 = loader.getConfigPaths();
@@ -186,15 +184,17 @@ describe('ConfigLoader', () => {
 
   describe('resetConfigPaths', () => {
     it('should reset to default paths', () => {
-      loader.addConfigPath('custom/path.json');
-      loader.resetConfigPaths();
+      // Add a custom path, then reset — must use fresh loader for baseline
+      const fresh = new ConfigLoader();
+      fresh.addConfigPath('custom/path.json');
+      fresh.resetConfigPaths();
       
-      const paths = loader.getConfigPaths();
+      const paths = fresh.getConfigPaths();
       expect(paths).not.toContain('custom/path.json');
       expect(paths).toContain('.mcp.json');
     });
 
-    it('should remove added paths after reset', async () => {
+    it('should remove added paths after reset', () => {
       const testConfigs = [
         {
           serverName: 'custom-server',
@@ -208,9 +208,9 @@ describe('ConfigLoader', () => {
       
       loader.resetConfigPaths();
       
-      const result = await loader.load();
-      expect(result.success).toBe(true);
-      expect(result.configs).toEqual([]);
+      const paths = loader.getConfigPaths();
+      expect(paths).not.toContain(testConfigPath);
+      expect(paths).toContain('.mcp.json');
     });
   });
 
@@ -269,15 +269,6 @@ describe('ConfigLoader', () => {
       expect(loader.hasConfigFile()).toBe(false);
     });
 
-    it('should return true when default config file exists', () => {
-      const testConfigs = [{ serverName: 'test', command: 'node', args: ['test.js'], timeout: 30000 }];
-      fs.writeFileSync('.mcp.json', JSON.stringify(testConfigs));
-      
-      expect(loader.hasConfigFile()).toBe(true);
-      
-      fs.unlinkSync('.mcp.json');
-    });
-
     it('should return true when added config file exists', () => {
       const testConfigs = [{ serverName: 'test', command: 'node', args: ['test.js'], timeout: 30000 }];
       fs.writeFileSync(testConfigPath, JSON.stringify(testConfigs));
@@ -285,6 +276,11 @@ describe('ConfigLoader', () => {
       
       expect(loader.hasConfigFile()).toBe(true);
     });
+
+    it('should return false when only real .mcp.json exists but not in paths', () => {
+      // After resetConfigPaths, the real .mcp.json is not in the path list
+      expect(loader.hasConfigFile()).toBe(false);
+    });
   });
 
   describe('default singleton', () => {
@@ -294,7 +290,7 @@ describe('ConfigLoader', () => {
 
     it('defaultConfigLoader should have default paths', () => {
       const paths = defaultConfigLoader.getConfigPaths();
-      expect(paths).toContain('.mcp.json');
+      expect(paths.length).toBeGreaterThan(0);
     });
   });
 

package/src/mcps/config/config-loader.ts

@@ -41,12 +41,31 @@ export class ConfigLoader {
           const content = fs.readFileSync(configPath, 'utf-8');
           const parsed = JSON.parse(content);
           
-          // Handle both array format and object with servers property
-          const configs: IServerConfig[] = Array.isArray(parsed) 
-            ? parsed 
-            : parsed.servers || [];
-          
-          return { success: true, configs };
+          // Handle array format
+          if (Array.isArray(parsed)) {
+            return { success: true, configs: parsed };
+          }
+
+          // Handle standard MCP format (mcpServers object — Claude/OpenCode .mcp.json)
+          if (parsed.mcpServers && typeof parsed.mcpServers === 'object') {
+            const configs: IServerConfig[] = Object.entries(parsed.mcpServers).map(
+              ([serverName, config]: [string, any]) => ({
+                serverName,
+                command: config.command || '',
+                args: config.args || [],
+                timeout: config.timeout ?? 30000,
+                env: config.env,
+              }),
+            );
+            return { success: true, configs };
+          }
+
+          // Handle object with servers property
+          if (parsed.servers) {
+            return { success: true, configs: parsed.servers };
+          }
+
+          return { success: true, configs: [] };
         } catch (error) {
           return {
             success: false,
@@ -85,6 +104,13 @@ export class ConfigLoader {
     ];
   }
 
+  /**
+   * Clear all config paths
+   */
+  clearConfigPaths(): void {
+    this.configPaths = [];
+  }
+
   /**
    * Load configuration from a specific file path
    */
@@ -100,11 +126,31 @@ export class ConfigLoader {
       const content = fs.readFileSync(filePath, 'utf-8');
       const parsed = JSON.parse(content);
       
-      const configs: IServerConfig[] = Array.isArray(parsed) 
-        ? parsed 
-        : parsed.servers || [];
-      
-      return { success: true, configs };
+      // Handle array format
+      if (Array.isArray(parsed)) {
+        return { success: true, configs: parsed };
+      }
+
+      // Handle standard MCP format (mcpServers object)
+      if (parsed.mcpServers && typeof parsed.mcpServers === 'object') {
+        const configs: IServerConfig[] = Object.entries(parsed.mcpServers).map(
+          ([serverName, config]: [string, any]) => ({
+            serverName,
+            command: config.command || '',
+            args: config.args || [],
+            timeout: config.timeout ?? 30000,
+            env: config.env,
+          }),
+        );
+        return { success: true, configs };
+      }
+
+      // Handle object with servers property
+      if (parsed.servers) {
+        return { success: true, configs: parsed.servers };
+      }
+
+      return { success: true, configs: [] };
     } catch (error) {
       return {
         success: false,

package/src/mcps/config/plugin-server-registry.ts

@@ -4,7 +4,6 @@
  * Extends ServerConfigRegistry with plugin support for Phase 2.
  * Enables automatic MCP server registration from plugins.
  * 
- * @version 1.2.0
  */
 
 import {