0xray 2.1.2 → 2.1.3

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

@@ -4,18 +4,12 @@
  * 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 { 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";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface ComponentInitResult {
   success: boolean;
@@ -92,8 +86,7 @@ interface ShutdownFrameworkArgs {
   saveState?: boolean;
 }
 
-class XrayBootOrchestratorServer {
-  private server: Server;
+class XrayBootOrchestratorServer extends XrayKnowledgeSkillBase {
   private bootStatus: {
     initialized: boolean;
     startTime: number;
@@ -118,16 +111,7 @@ class XrayBootOrchestratorServer {
   ];
 
   constructor() {
-    this.server = new Server(
-      {
-        name: "boot-orchestrator", version: "2.0.1",
-      },
-      {
-        capabilities: {
-          tools: {},
-        },
-      },
-    );
+    super("boot-orchestrator", "2.0.1");
 
     this.bootStatus = {
       initialized: false,
@@ -140,6 +124,77 @@ 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.handlers = {
+      "execute-boot-sequence": async (args) => this.handleExecuteBootSequence(args as unknown as ExecuteBootSequenceArgs),
+      "get-boot-status": async (args) => this.handleGetBootStatus(args as unknown as GetBootStatusArgs),
+      "initialize-component": async (args) => this.handleInitializeComponent(args as unknown as InitializeComponentArgs),
+      "validate-boot-dependencies": async (args) => this.handleValidateBootDependencies(args as unknown as ValidateBootDependenciesArgs),
+      "shutdown-framework": async (args) => this.handleShutdownFramework(args as unknown as ShutdownFrameworkArgs),
+    };
     this.setupToolHandlers();
     void frameworkLogger.log("mcps/boot-orchestrator", "initialize", "info");
   }
@@ -185,101 +240,6 @@ 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
-    this.server.setRequestHandler(
-      CallToolRequestSchema,
-      async (request: CallToolRequest) => {
-        const { name, arguments: args } = request.params;
-
-        switch (name) {
-          case "execute-boot-sequence":
-            return await this.handleExecuteBootSequence(args as unknown as ExecuteBootSequenceArgs);
-          case "get-boot-status":
-            return await this.handleGetBootStatus(args as unknown as GetBootStatusArgs);
-          case "initialize-component":
-            return await this.handleInitializeComponent(args as unknown as InitializeComponentArgs);
-          case "validate-boot-dependencies":
-            return await this.handleValidateBootDependencies(args as unknown as ValidateBootDependenciesArgs);
-          case "shutdown-framework":
-            return await this.handleShutdownFramework(args as unknown as ShutdownFrameworkArgs);
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      },
-    );
-  }
-
   private async handleExecuteBootSequence(args: ExecuteBootSequenceArgs) {
     const config = args.config || {};
     const skipHealthChecks = args.skipHealthChecks || false;
@@ -1065,18 +1025,12 @@ ${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]}`) {
   const server = new XrayBootOrchestratorServer();
-  server.run().catch((error) => frameworkLogger.log("mcps/boot-orchestrator", "run", "error", { error: String(error) }));
+  server.run("boot-orchestrator").catch((error) => frameworkLogger.log("mcps/boot-orchestrator", "run", "error", { error: String(error) }));
 }
 
 export { XrayBootOrchestratorServer };

package/src/mcps/config/__tests__/server-config-registry.test.ts

@@ -164,38 +164,47 @@ describe('ServerConfigRegistry', () => {
       expect(config.timeout).toBe(30000);
     });
 
-    it('should use STRRAY_DEV_PATH env var in dynamic config', () => {
-      const originalEnv = process.env.STRRAY_DEV_PATH;
-      process.env.STRRAY_DEV_PATH = 'custom-dist';
+    it('should use XRAY_DEV_PATH env var in dynamic config', () => {
+      const originalXrayEnv = process.env.XRAY_DEV_PATH;
+      const originalStrrayEnv = ;
+      process.env.XRAY_DEV_PATH = 'custom-dist';
+       = 'custom-dist';
       
       const config = registry.createDynamicConfig('test-server');
       expect(config.args[0]).toContain('custom-dist');
       
-      process.env.STRRAY_DEV_PATH = originalEnv;
+      process.env.XRAY_DEV_PATH = originalXrayEnv;
+       = originalStrrayEnv;
     });
   });
 
   describe('environment path handling', () => {
-    it('should use resolved framework path when STRRAY_DEV_PATH is not set', () => {
-      const originalEnv = process.env.STRRAY_DEV_PATH;
-      delete process.env.STRRAY_DEV_PATH;
+    it('should use resolved framework path when XRAY_DEV_PATH is not set', () => {
+      const originalXrayEnv = process.env.XRAY_DEV_PATH;
+      const originalStrrayEnv = ;
+      delete process.env.XRAY_DEV_PATH;
+      delete ;
       
       const freshRegistry = new ServerConfigRegistry();
       const config = freshRegistry.get('code-review');
       expect(config?.args[0]).toContain('.server.js');
       
-      process.env.STRRAY_DEV_PATH = originalEnv;
+      process.env.XRAY_DEV_PATH = originalXrayEnv;
+       = originalStrrayEnv;
     });
 
-    it('should use STRRAY_DEV_PATH when set', () => {
-      const originalEnv = process.env.STRRAY_DEV_PATH;
-      process.env.STRRAY_DEV_PATH = 'dist';
+    it('should use XRAY_DEV_PATH when set', () => {
+      const originalXrayEnv = process.env.XRAY_DEV_PATH;
+      const originalStrrayEnv = ;
+      process.env.XRAY_DEV_PATH = 'dist';
+       = 'dist';
       
       const freshRegistry = new ServerConfigRegistry();
       const config = freshRegistry.get('code-review');
       expect(config?.args[0]).toContain('dist/');
       
-      process.env.STRRAY_DEV_PATH = originalEnv;
+      process.env.XRAY_DEV_PATH = originalXrayEnv;
+       = originalStrrayEnv;
     });
   });
 

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

@@ -20,14 +20,14 @@ import fs from 'fs';
 /**
  * Resolve the correct framework root and MCP servers path.
  * Priority:
- *   1. STRRAY_DEV_PATH env var (explicit dev override)
+ *   1. XRAY_DEV_PATH env var (explicit dev override)
  *   2. The "xray" field in the nearest package.json that declares it (works in both source tree and installed package)
  *   3. Safe fallback to node_modules/0xray/dist
  */
 function resolveFrameworkPaths(): { frameworkRoot: string; mcpServersPath: string } {
   // Highest priority: explicit environment override
-  if (process.env.STRRAY_DEV_PATH) {
-    const devPath = process.env.STRRAY_DEV_PATH;
+  if (process.env.XRAY_DEV_PATH) {
+    const devPath: string = process.env.XRAY_DEV_PATH || "";
     return {
       frameworkRoot: devPath,
       mcpServersPath: join(devPath, 'mcps'),