0xray 3.0.11 → 3.0.14

package/src/mcps/lint.server.ts

@@ -4,10 +4,15 @@
  * 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[];
@@ -28,73 +33,111 @@ interface LintResults {
   details: string[];
 }
 
-class XrayLintServer extends XrayKnowledgeSkillBase {
-  constructor() {
-    super("lint", "2.0.1");
+class XrayLintServer {
+  private server: Server;
 
-    this.tools = [
+  constructor() {
+    this.server = new Server(
       {
-        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", version: "1.22.67",
       },
       {
-        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",
-            },
-          },
+        capabilities: {
+          tools: {},
         },
       },
-    ];
-
-    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(
       "lint.server",
-      "-xray-lint-mcp-server-initialized-",
+      "-strray-lint-mcp-server-initialized-",
       "info",
       { message: "0xRay Lint MCP Server initialized" },
     );
   }
 
+  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;
@@ -418,12 +461,23 @@ ${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",
+      "-strray-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("lint").catch((error) => frameworkLogger.log("mcps/lint", "run", "error", { error: String(error) }));
+  server.run().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.XRAY_PURE_MCP_MODE) === 'true';
+    return process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true';
   }
 
   /**
@@ -344,17 +344,17 @@ export class MCPClient extends EventEmitter {
       ],
       'framework-help': [
         {
-          name: 'xray_get_capabilities',
+          name: 'strray_get_capabilities',
           description: 'Get 0xRay framework capabilities',
           inputSchema: { type: 'object', properties: {} },
         },
         {
-          name: 'xray_get_commands',
+          name: 'strray_get_commands',
           description: 'Get available 0xRay commands',
           inputSchema: { type: 'object', properties: {} },
         },
         {
-          name: 'xray_explain_capability',
+          name: 'strray_explain_capability',
           description: 'Explain a specific capability',
           inputSchema: {
             type: 'object',
@@ -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 XRAY_PURE_MCP_MODE=true.`
+          `All fallbacks are disabled when STRRAY_FORCE_MCP_GOVERNANCE=true.`
         );
       }
 

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

@@ -4,11 +4,16 @@
  * 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[];
@@ -31,47 +36,73 @@ interface ModelHealthReportData {
   summary: { total: number; healthy: number; issues: number };
 }
 
-class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
-  constructor() {
-    super("model-health-check", "2.0.1");
+class XrayModelHealthCheckServer {
+  private server: Server;
 
-    this.tools = [
+  constructor() {
+    this.server = new Server(
       {
-        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",
-            },
-          },
+        name: "model-health-check", version: "1.22.67",
+      },
+      {
+        capabilities: {
+          tools: {},
         },
       },
-    ];
-
-    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;
@@ -244,12 +275,18 @@ class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
 
     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.run("model-health-check").catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
+  server.start().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
 }
 
 export default XrayModelHealthCheckServer;

package/src/mcps/orchestrator/server.ts

@@ -5,8 +5,6 @@
  * Provides a clean API while hiding internal complexity
  */
 
-import { realpathSync } from "fs";
-import { fileURLToPath } from "url";
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import {
@@ -14,7 +12,7 @@ import {
   ListToolsRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 import { frameworkLogger } from '../../core/framework-logger.js';
-import { XrayStateManager } from '../../state/state-manager.js';
+import { StringRayStateManager } from '../../state/state-manager.js';
 import { MultiAgentOrchestrationCoordinator } from '../../orchestrator/multi-agent-orchestration-coordinator.js';
 
 import { TaskHandler } from './handlers/task-handler.js';
@@ -47,7 +45,7 @@ export class OrchestratorServer {
 
   constructor() {
     // Initialize actual coordinator
-    const stateManager = new XrayStateManager();
+    const stateManager = new StringRayStateManager();
     this.coordinator = new MultiAgentOrchestrationCoordinator(stateManager);
     
     // Initialize handlers
@@ -378,8 +376,8 @@ export function createOrchestratorServer(): OrchestratorServer {
   return serverInstance;
 }
 
-// Run if called directly (realpath handles /var → /private/var on macOS)
-if (process.argv[1] && realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1])) {
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
   const server = createOrchestratorServer();
   server.start().catch((error) => {
     frameworkLogger.log('orchestrator.server', 'fatal-error', 'error', {

package/src/mcps/orchestrator.server.ts

@@ -0,0 +1,34 @@
+/**
+ * 0xRay Orchestrator MCP Server
+ * 
+ * This is a re-export from the new modular structure.
+ * For the full implementation, see: src/mcps/orchestrator/
+ * 
+ * @deprecated Use src/mcps/orchestrator/server.ts instead
+ */
+
+import { frameworkLogger } from '../core/framework-logger.js';
+
+export { OrchestratorServer, createOrchestratorServer } from './orchestrator/server.js';
+
+// Re-export types for backward compatibility
+export type {
+  AgentCapability,
+  OrchestrationTask,
+  ExecutionPlan,
+  OrchestrationResult,
+  ComplexityAnalysis,
+  TaskValidation,
+  OrchestrationStatus,
+  TaskExecutionContext,
+} from './orchestrator/types.js';
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const { createOrchestratorServer } = await import('./orchestrator/server.js');
+  const server = createOrchestratorServer();
+  server.start().catch((error) => {
+    frameworkLogger.log("mcps/orchestrator", "start", "error", { error: String(error) });
+    process.exit(1);
+  });
+}

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

@@ -4,12 +4,17 @@
  * 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;
@@ -52,73 +57,23 @@ interface ResourceMetrics {
   recommendations: string[];
 }
 
-class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
+class XrayPerformanceAnalysisServer {
+  private server: Server;
   private startTime: number;
 
   constructor() {
-    super("performance-analysis", "2.0.1");
-
-    this.startTime = Date.now();
-
-    this.tools = [
+    this.server = new Server(
       {
-        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: "performance-analysis", version: "1.22.67",
       },
       {
-        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",
-            },
-          },
+        capabilities: {
+          tools: {},
         },
       },
-    ];
-
-    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",
@@ -127,6 +82,81 @@ class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
     );
   }
 
+  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;
@@ -660,12 +690,26 @@ ${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("performance-analysis").catch((error) => frameworkLogger.log("mcps/performance-analysis", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/performance-analysis", "run", "error", { error: String(error) }));
 }
 
 export { XrayPerformanceAnalysisServer };