0xray 2.1.2 → 2.1.3

package/src/mcps/lint.server.ts

@@ -4,15 +4,10 @@
  * Comprehensive ESLint validation and automated code quality checking
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
 import { execFileSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface LintArgs {
   files?: string[];
@@ -33,20 +28,63 @@ interface LintResults {
   details: string[];
 }
 
-class XrayLintServer {
-  private server: Server;
-
+class XrayLintServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
+    super("lint", "2.0.1");
+
+    this.tools = [
       {
-        name: "lint", version: "2.0.1",
+        name: "lint",
+        description:
+          "Comprehensive ESLint validation and automated code quality checking",
+        inputSchema: {
+          type: "object",
+          properties: {
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Specific files to lint (optional - lints all if empty)",
+            },
+            fix: {
+              type: "boolean",
+              default: false,
+              description:
+                "Automatically fix linting issues where possible",
+            },
+            strict: {
+              type: "boolean",
+              default: false,
+              description: "Use strict linting rules",
+            },
+          },
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "lint-check",
+        description: "Check code quality without making changes",
+        inputSchema: {
+          type: "object",
+          properties: {
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description: "Files to check",
+            },
+            rules: {
+              type: "array",
+              items: { type: "string" },
+              description: "Specific ESLint rules to check",
+            },
+          },
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "lint": async (args) => this.handleLint(args as unknown as LintArgs),
+      "lint-check": async (args) => this.handleLintCheck(args as unknown as LintCheckArgs),
+    };
 
     this.setupToolHandlers();
     void frameworkLogger.log(
@@ -57,87 +95,6 @@ class XrayLintServer {
     );
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "lint",
-            description:
-              "Comprehensive ESLint validation and automated code quality checking",
-            inputSchema: {
-              type: "object",
-              properties: {
-                files: {
-                  type: "array",
-                  items: { type: "string" },
-                  description:
-                    "Specific files to lint (optional - lints all if empty)",
-                },
-                fix: {
-                  type: "boolean",
-                  default: false,
-                  description:
-                    "Automatically fix linting issues where possible",
-                },
-                strict: {
-                  type: "boolean",
-                  default: false,
-                  description: "Use strict linting rules",
-                },
-              },
-            },
-          },
-          {
-            name: "lint-check",
-            description: "Check code quality without making changes",
-            inputSchema: {
-              type: "object",
-              properties: {
-                files: {
-                  type: "array",
-                  items: { type: "string" },
-                  description: "Files to check",
-                },
-                rules: {
-                  type: "array",
-                  items: { type: "string" },
-                  description: "Specific ESLint rules to check",
-                },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      try {
-        switch (name) {
-          case "lint":
-            return await this.handleLint(args as unknown as LintArgs);
-          case "lint-check":
-            return await this.handleLintCheck(args as unknown as LintCheckArgs);
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `❌ Tool execution failed: ${error instanceof Error ? error.message : String(error)}`,
-            },
-          ],
-        };
-      }
-    });
-  }
-
   private async handleLint(args: LintArgs) {
     const files = args.files || [];
     const fix = args.fix || false;
@@ -461,23 +418,12 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 - Warnings: ${results.issues.warnings}
 - Fixed: ${results.issues.fixed}`;
   }
-
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    await frameworkLogger.log(
-      "lint.server",
-      "-xray-lint-mcp-server-started-",
-      "info",
-      { message: "0xRay Lint MCP Server started" },
-    );
-  }
 }
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayLintServer();
-  server.run().catch((error) => frameworkLogger.log("mcps/lint", "run", "error", { error: String(error) }));
+  server.run("lint").catch((error) => frameworkLogger.log("mcps/lint", "run", "error", { error: String(error) }));
 }
 
 export { XrayLintServer };

package/src/mcps/mcp-client.ts

@@ -153,7 +153,7 @@ export class MCPClient extends EventEmitter {
    * Pure MCP mode — simulation and generic fallbacks are disabled.
    */
   private get isPureMcpMode(): boolean {
-    return process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true';
+    return (process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true';
   }
 
   /**
@@ -470,7 +470,7 @@ export class MCPClient extends EventEmitter {
       if (this.isPureMcpMode) {
         throw new Error(
           `[PURE MCP] No real response for ${serverName}/${toolName}. ` +
-          `All fallbacks are disabled when STRRAY_FORCE_MCP_GOVERNANCE=true.`
+          `All fallbacks are disabled when XRAY_FORCE_MCP_GOVERNANCE=true.`
         );
       }
 

package/src/mcps/model-health-check.server.ts

@@ -4,16 +4,11 @@
  * Advanced model compatibility validation and dynamic health assessment
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { modelRouter } from "../core/model-router.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
 import { execSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface ModelHealthCheckArgs {
   models?: string[];
@@ -36,73 +31,47 @@ interface ModelHealthReportData {
   summary: { total: number; healthy: number; issues: number };
 }
 
-class XrayModelHealthCheckServer {
-  private server: Server;
-
+class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
-      {
-        name: "model-health-check", version: "2.0.1",
-      },
+    super("model-health-check", "2.0.1");
+
+    this.tools = [
       {
-        capabilities: {
-          tools: {},
+        name: "model-health-check",
+        description:
+          "Advanced model compatibility validation and dynamic health assessment",
+        inputSchema: {
+          type: "object",
+          properties: {
+            models: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Specific models to check (optional - checks all configured if empty)",
+            },
+            compatibility: {
+              type: "boolean",
+              default: true,
+              description: "Include compatibility matrix in results",
+            },
+            performance: {
+              type: "boolean",
+              default: true,
+              description: "Include performance metrics in results",
+            },
+          },
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "model-health-check": async (args) => this.handleModelHealthCheck((args || {}) as unknown as ModelHealthCheckArgs),
+    };
 
     this.setupToolHandlers();
     frameworkLogger.log("mcps/model-health-check", "initialize", "info");
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "model-health-check",
-            description:
-              "Advanced model compatibility validation and dynamic health assessment",
-            inputSchema: {
-              type: "object",
-              properties: {
-                models: {
-                  type: "array",
-                  items: { type: "string" },
-                  description:
-                    "Specific models to check (optional - checks all configured if empty)",
-                },
-                compatibility: {
-                  type: "boolean",
-                  default: true,
-                  description: "Include compatibility matrix in results",
-                },
-                performance: {
-                  type: "boolean",
-                  default: true,
-                  description: "Include performance metrics in results",
-                },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "model-health-check":
-          return await this.handleModelHealthCheck((args || {}) as unknown as ModelHealthCheckArgs);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-  }
-
   private async handleModelHealthCheck(args: ModelHealthCheckArgs) {
     const models = args.models || [modelRouter.getValidatedModel()];
     const includeCompatibility = args.compatibility !== false;
@@ -275,18 +244,12 @@ class XrayModelHealthCheckServer {
 
     return report;
   }
-
-  public async start() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    frameworkLogger.log("mcps/model-health-check", "start", "info");
-  }
 }
 
 // Start the server if this file is run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayModelHealthCheckServer();
-  server.start().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
+  server.run("model-health-check").catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
 }
 
 export default XrayModelHealthCheckServer;

package/src/mcps/performance-analysis.server.ts

@@ -4,17 +4,12 @@
  * Comprehensive metrics analysis for framework integration and optimization
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
 import { execSync } from "child_process";
 import fs from "fs";
 import os from "os";
 import path from "path";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface AnalysisMetrics {
   runtime?: RuntimeMetrics;
@@ -57,23 +52,73 @@ interface ResourceMetrics {
   recommendations: string[];
 }
 
-class XrayPerformanceAnalysisServer {
-  private server: Server;
+class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
   private startTime: number;
 
   constructor() {
-    this.server = new Server(
+    super("performance-analysis", "2.0.1");
+
+    this.startTime = Date.now();
+
+    this.tools = [
       {
-        name: "performance-analysis", version: "2.0.1",
+        name: "performance-analysis",
+        description:
+          "Comprehensive metrics analysis for framework integration and optimization",
+        inputSchema: {
+          type: "object",
+          properties: {
+            scope: {
+              type: "string",
+              enum: [
+                "full",
+                "runtime",
+                "build",
+                "resources",
+                "bottlenecks",
+              ],
+              default: "full",
+              description: "Scope of performance analysis",
+            },
+            duration: {
+              type: "number",
+              default: 30,
+              description: "Analysis duration in seconds",
+            },
+            detailed: {
+              type: "boolean",
+              default: false,
+              description: "Include detailed metrics and recommendations",
+            },
+          },
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "bottleneck-detection",
+        description:
+          "Identify performance bottlenecks in framework operations",
+        inputSchema: {
+          type: "object",
+          properties: {
+            operation: {
+              type: "string",
+              description: "Specific operation to analyze",
+            },
+            threshold: {
+              type: "number",
+              default: 1000,
+              description: "Performance threshold in milliseconds",
+            },
+          },
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "performance-analysis": async (args) => this.handlePerformanceAnalysis(args as Record<string, unknown> | undefined),
+      "bottleneck-detection": async (args) => this.handleBottleneckDetection(args as Record<string, unknown> | undefined),
+    };
 
-    this.startTime = Date.now();
     this.setupToolHandlers();
     frameworkLogger.log(
       "mcp-performance-analysis",
@@ -82,81 +127,6 @@ class XrayPerformanceAnalysisServer {
     );
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "performance-analysis",
-            description:
-              "Comprehensive metrics analysis for framework integration and optimization",
-            inputSchema: {
-              type: "object",
-              properties: {
-                scope: {
-                  type: "string",
-                  enum: [
-                    "full",
-                    "runtime",
-                    "build",
-                    "resources",
-                    "bottlenecks",
-                  ],
-                  default: "full",
-                  description: "Scope of performance analysis",
-                },
-                duration: {
-                  type: "number",
-                  default: 30,
-                  description: "Analysis duration in seconds",
-                },
-                detailed: {
-                  type: "boolean",
-                  default: false,
-                  description: "Include detailed metrics and recommendations",
-                },
-              },
-            },
-          },
-          {
-            name: "bottleneck-detection",
-            description:
-              "Identify performance bottlenecks in framework operations",
-            inputSchema: {
-              type: "object",
-              properties: {
-                operation: {
-                  type: "string",
-                  description: "Specific operation to analyze",
-                },
-                threshold: {
-                  type: "number",
-                  default: 1000,
-                  description: "Performance threshold in milliseconds",
-                },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "performance-analysis":
-          return await this.handlePerformanceAnalysis(args);
-        case "bottleneck-detection":
-          return await this.handleBottleneckDetection(args);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-  }
-
   private async handlePerformanceAnalysis(args: Record<string, unknown> | undefined) {
     const scope = (args?.scope as string) || "full";
     const duration = (args?.duration as number) || 30;
@@ -690,26 +660,12 @@ ${results.recommendations.map((r) => `• 💡 ${r}`).join("\n") || "No recommen
 
     return report;
   }
-
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    const jobId = generateJobId("mcp-performance-analysis-server");
-    await frameworkLogger.log(
-      "mcp-performance-analysis",
-      "server-started",
-      "success",
-      {},
-      undefined, // sessionId
-      jobId,
-    );
-  }
 }
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayPerformanceAnalysisServer();
-  server.run().catch((error) => frameworkLogger.log("mcps/performance-analysis", "run", "error", { error: String(error) }));
+  server.run("performance-analysis").catch((error) => frameworkLogger.log("mcps/performance-analysis", "run", "error", { error: String(error) }));
 }
 
 export { XrayPerformanceAnalysisServer };