0xray 3.1.0 → 3.2.0

package/src/mcps/knowledge-skills/project-analysis.server.ts

@@ -5,16 +5,10 @@
  * and pattern recognition - provides deep project intelligence
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolResult,
-} from "@modelcontextprotocol/sdk/types.js";
 import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 
 interface ProjectMetrics {
   totalFiles: number;
@@ -136,30 +130,10 @@ interface McpToolResponse {
   content: Array<{ type: "text"; text: string }>;
 }
 
-class ProjectAnalysisServer {
-  private server: Server;
-
+class ProjectAnalysisServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
-      {
-        name: "project-analysis", version: "1.22.67",
-      },
-      {
-        capabilities: {
-          tools: {},
-        },
-      },
-    );
-
-    this.setupToolHandlers();
-    // Server initialization - removed unnecessary startup logging
-  }
-
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
+    super("project-analysis", "3.1.0");
+    this.tools = [
           {
             name: "analyze-project-structure",
             description:
@@ -295,34 +269,15 @@ class ProjectAnalysisServer {
               required: ["proposalTitle", "proposalDescription"],
             },
           },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> => {
-      const { name, arguments: args } = request.params;
-
-      try {
-        switch (name) {
-          case "analyze-project-structure":
-            return await this.analyzeProjectStructure(args as unknown as AnalyzeProjectStructureArgs) as CallToolResult;
-          case "assess-project-complexity":
-            return await this.assessProjectComplexity(args as unknown as AssessProjectComplexityArgs) as CallToolResult;
-          case "identify-project-patterns":
-            return await this.identifyProjectPatterns(args as unknown as IdentifyProjectPatternsArgs) as CallToolResult;
-          case "analyze-project-health":
-            return await this.analyzeProjectHealth(args as unknown as AnalyzeProjectHealthArgs) as CallToolResult;
-          case "analyze_proposal":
-            return await this.analyzeProposal(args as any) as CallToolResult;
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        frameworkLogger.log("mcps/project-analysis", "tool", "error", { tool: name, error: String(error) });
-        throw error;
-      }
-    });
+    ];
+    this.handlers = {
+      "analyze-project-structure": async (args) => this.analyzeProjectStructure(args as unknown as AnalyzeProjectStructureArgs),
+      "assess-project-complexity": async (args) => this.assessProjectComplexity(args as unknown as AssessProjectComplexityArgs),
+      "identify-project-patterns": async (args) => this.identifyProjectPatterns(args as unknown as IdentifyProjectPatternsArgs),
+      "analyze-project-health": async (args) => this.analyzeProjectHealth(args as unknown as AnalyzeProjectHealthArgs),
+      "analyze_proposal": async (args) => this.analyzeProposal(args as any),
+    };
+    this.setupToolHandlers();
   }
 
   private async analyzeProjectStructure(args: AnalyzeProjectStructureArgs): Promise<McpToolResponse> {
@@ -1037,73 +992,11 @@ class ProjectAnalysisServer {
     };
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    await frameworkLogger.log(
-      "mcp-project-analysis",
-      "server-started",
-      "success",
-    );
-
-    const cleanup = async (signal: string) => {
-      frameworkLogger.log("mcps/project-analysis", "shutdown", "info", { signal });
-
-      // Set a timeout to force exit if graceful shutdown fails
-      const timeout = setTimeout(() => {
-        frameworkLogger.log("mcps/project-analysis", "shutdown", "error", { message: "Graceful shutdown timeout, forcing exit..." });
-        process.exit(1);
-      }, 5000); // 5 second timeout
-
-      try {
-        if (this.server && typeof this.server.close === "function") {
-          await this.server.close();
-        }
-        clearTimeout(timeout);
-        frameworkLogger.log("mcps/project-analysis", "shutdown", "success");
-        process.exit(0);
-      } catch (error) {
-        clearTimeout(timeout);
-        frameworkLogger.log("mcps/project-analysis", "shutdown", "error", { message: `Error during server shutdown: ${String(error)}` });
-        process.exit(1);
-      }
-    };
-
-    // Handle multiple shutdown signals
-    process.on("SIGINT", () => cleanup("SIGINT"));
-    process.on("SIGTERM", () => cleanup("SIGTERM"));
-    process.on("SIGHUP", () => cleanup("SIGHUP"));
 
-    // Monitor parent process (opencode) and shutdown if it dies
-    const checkParent = () => {
-      try {
-        process.kill(process.ppid, 0); // Check if parent is alive
-        setTimeout(checkParent, 1000); // Check again in 1 second
-      } catch (error) {
-        // Parent process died, shut down gracefully
-        frameworkLogger.log("mcps/project-analysis", "parent-death", "info");
-        cleanup("parent-process-death");
-      }
-    };
-
-    // Start monitoring parent process
-    setTimeout(checkParent, 2000); // Start checking after 2 seconds
-
-    // Handle uncaught exceptions and unhandled rejections
-    process.on("uncaughtException", (error) => {
-      frameworkLogger.log("mcps/project-analysis", "uncaughtException", "error", { error: String(error) });
-      cleanup("uncaughtException");
-    });
-
-    process.on("unhandledRejection", (reason, promise) => {
-      frameworkLogger.log("mcps/project-analysis", "unhandledRejection", "error", { error: String(reason) });
-      cleanup("unhandledRejection");
-    });
-  }
 }
 
 // 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 ProjectAnalysisServer();
   server.run().catch((error: unknown) => frameworkLogger.log("mcps/project-analysis", "run", "error", { error: String(error) }));
 }

package/src/mcps/knowledge-skills/refactoring-strategies.server.ts

@@ -5,15 +5,9 @@
  * modernization, and code improvement patterns
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as fs from "fs";
 import { frameworkLogger } from "../../core/framework-logger.js";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolResult,
-} from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 
 interface RefactoringOpportunity {
   type:
@@ -154,29 +148,10 @@ interface RollbackPlan {
   emergencyProcedures: string[];
 }
 
-class XrayRefactoringStrategiesServer {
-  private server: Server;
-
+class XrayRefactoringStrategiesServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
-      {
-        name: "refactoring-strategies", version: "1.22.67",
-      },
-      {
-        capabilities: {
-          tools: {},
-        },
-      },
-    );
-
-    this.setupToolHandlers();
-    // Server initialization - removed unnecessary startup logging
-  }
-
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
+    super("refactoring-strategies", "3.1.0");
+    this.tools = [
           {
             name: "analyze_technical_debt",
             description:
@@ -295,26 +270,14 @@ class XrayRefactoringStrategiesServer {
               required: ["codePath"],
             },
           },
-        ],
-      };
-    });
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "analyze_technical_debt":
-          return await this.analyzeTechnicalDebt(args as unknown as AnalyzeTechnicalDebtArgs) as CallToolResult;
-        case "suggest_refactoring":
-          return await this.suggestRefactoring(args as unknown as SuggestRefactoringArgs) as CallToolResult;
-        case "generate_refactoring_plan":
-          return await this.generateRefactoringPlan(args as unknown as GenerateRefactoringPlanArgs) as CallToolResult;
-        case "modernize_codebase":
-          return await this.modernizeCodebase(args as unknown as ModernizeCodebaseArgs) as CallToolResult;
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
+    ];
+    this.handlers = {
+      "analyze_technical_debt": async (args) => this.analyzeTechnicalDebt(args as unknown as AnalyzeTechnicalDebtArgs),
+      "suggest_refactoring": async (args) => this.suggestRefactoring(args as unknown as SuggestRefactoringArgs),
+      "generate_refactoring_plan": async (args) => this.generateRefactoringPlan(args as unknown as GenerateRefactoringPlanArgs),
+      "modernize_codebase": async (args) => this.modernizeCodebase(args as unknown as ModernizeCodebaseArgs),
+    };
+    this.setupToolHandlers();
   }
 
   private async analyzeTechnicalDebt(args: AnalyzeTechnicalDebtArgs) {
@@ -1071,20 +1034,11 @@ class XrayRefactoringStrategiesServer {
     return icons[effort as keyof typeof icons] || "❓";
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    
-    // Use centralized shutdown handler
-    createGracefulShutdown({
-      serverName: "refactoring-strategies.server",
-      server: this.server,
-    });
-  }
+
 }
 
 // Run the server if this file is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = new XrayRefactoringStrategiesServer();
   server.run().catch(() => {});
 }

package/src/mcps/knowledge-skills/security-audit.server.ts

@@ -5,16 +5,9 @@
  * and compliance validation - ensures production-ready security posture
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolResult,
-} from "@modelcontextprotocol/sdk/types.js";
 import * as fs from "fs";
 import * as path from "path";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { tryLLMGovernance } from "../../governance/llm-governance-provider.js";
 
 interface SecurityVulnerability {
@@ -85,151 +78,29 @@ interface AnalyzeProposalArgs {
   proposalType?: string;
 }
 
-class XraySecurityAuditServer {
-  private server: Server;
+class XraySecurityAuditServer extends XrayKnowledgeSkillBase {
 
   constructor() {
-    this.server = new Server(
-      {
-        name: "security-audit", version: "1.22.67",
-      },
-      {
-        capabilities: {
-          tools: {},
-        },
-      },
-    );
+    super("security-audit", "3.1.0");
+
+    this.tools = [
+      { name: "audit_security", description: "Perform comprehensive security audit on codebase files", inputSchema: { type: "object", properties: { files: { type: "array", items: { type: "string" }, description: "List of file paths to audit" }, includeDependencies: { type: "boolean", description: "Include dependency vulnerability analysis", default: true }, complianceFrameworks: { type: "array", items: { type: "string", enum: ["owasp-top-10", "nist", "iso-27001", "pci-dss"] }, description: "Compliance frameworks to check against" } }, required: ["files"] } },
+      { name: "check_vulnerability", description: "Check specific security vulnerability patterns in a file", inputSchema: { type: "object", properties: { filePath: { type: "string", description: "Path to the file to check" }, vulnerabilityType: { type: "string", enum: ["injection", "authentication", "authorization", "cryptography", "xss", "csrf", "secrets", "configuration"] }, severity: { type: "string", enum: ["critical", "high", "medium", "low", "info"], description: "Minimum severity level to report" } }, required: ["filePath", "vulnerabilityType"] } },
+      { name: "generate_security_report", description: "Generate comprehensive security report with remediation steps", inputSchema: { type: "object", properties: { auditResults: { type: "object", description: "Results from audit_security tool" }, format: { type: "string", enum: ["markdown", "json", "html"], default: "markdown" }, includeRemediation: { type: "boolean", default: true } }, required: ["auditResults"] } },
+      { name: "analyze_proposal", description: "Analyze an inference proposal (pattern/bug/refactor) from a security perspective and return a structured governance decision", inputSchema: { type: "object", properties: { proposalTitle: { type: "string" }, proposalDescription: { type: "string" }, evidence: { type: "array", items: { type: "string" } }, proposalType: { type: "string" } }, required: ["proposalTitle", "proposalDescription"] } },
+    ];
+
+    this.handlers = {
+      audit_security: async (args) => this.auditSecurity(args as AuditSecurityArgs),
+      check_vulnerability: async (args) => this.checkVulnerability(args as CheckVulnerabilityArgs),
+      generate_security_report: async (args) => this.generateSecurityReport(args as GenerateSecurityReportArgs),
+      analyze_proposal: async (args) => this.analyzeProposal(args as AnalyzeProposalArgs),
+    };
 
     this.setupToolHandlers();
-    // Server initialization - removed unnecessary startup logging
   }
 
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "audit_security",
-            description:
-              "Perform comprehensive security audit on codebase files",
-            inputSchema: {
-              type: "object",
-              properties: {
-                files: {
-                  type: "array",
-                  items: { type: "string" },
-                  description: "List of file paths to audit",
-                },
-                includeDependencies: {
-                  type: "boolean",
-                  description: "Include dependency vulnerability analysis",
-                  default: true,
-                },
-                complianceFrameworks: {
-                  type: "array",
-                  items: {
-                    type: "string",
-                    enum: ["owasp-top-10", "nist", "iso-27001", "pci-dss"],
-                  },
-                  description: "Compliance frameworks to check against",
-                },
-              },
-              required: ["files"],
-            },
-          },
-          {
-            name: "check_vulnerability",
-            description:
-              "Check specific security vulnerability patterns in a file",
-            inputSchema: {
-              type: "object",
-              properties: {
-                filePath: {
-                  type: "string",
-                  description: "Path to the file to check",
-                },
-                vulnerabilityType: {
-                  type: "string",
-                  enum: [
-                    "injection",
-                    "authentication",
-                    "authorization",
-                    "cryptography",
-                    "xss",
-                    "csrf",
-                    "secrets",
-                    "configuration",
-                  ],
-                },
-                severity: {
-                  type: "string",
-                  enum: ["critical", "high", "medium", "low", "info"],
-                  description: "Minimum severity level to report",
-                },
-              },
-              required: ["filePath", "vulnerabilityType"],
-            },
-          },
-          {
-            name: "generate_security_report",
-            description:
-              "Generate comprehensive security report with remediation steps",
-            inputSchema: {
-              type: "object",
-              properties: {
-                auditResults: {
-                  type: "object",
-                  description: "Results from audit_security tool",
-                },
-                format: {
-                  type: "string",
-                  enum: ["markdown", "json", "html"],
-                  default: "markdown",
-                },
-                includeRemediation: {
-                  type: "boolean",
-                  default: true,
-                },
-              },
-              required: ["auditResults"],
-            },
-          },
-          {
-            name: "analyze_proposal",
-            description:
-              "Analyze an inference proposal (pattern/bug/refactor) from a security perspective and return a structured governance decision",
-            inputSchema: {
-              type: "object",
-              properties: {
-                proposalTitle: { type: "string" },
-                proposalDescription: { type: "string" },
-                evidence: { type: "array", items: { type: "string" } },
-                proposalType: { type: "string" },
-              },
-              required: ["proposalTitle", "proposalDescription"],
-            },
-          },
-        ],
-      };
-    });
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "audit_security":
-          return await this.auditSecurity(args as unknown as AuditSecurityArgs);
-        case "check_vulnerability":
-          return await this.checkVulnerability(args as unknown as CheckVulnerabilityArgs);
-        case "generate_security_report":
-          return await this.generateSecurityReport(args as unknown as GenerateSecurityReportArgs);
-        case "analyze_proposal":
-          return await this.analyzeProposal(args as AnalyzeProposalArgs) as CallToolResult;
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-  }
+  // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
 
   private async auditSecurity(args: AuditSecurityArgs) {
     const {
@@ -1153,20 +1024,11 @@ class XraySecurityAuditServer {
     };
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    
-    // Use centralized shutdown handler
-    createGracefulShutdown({
-      serverName: "security-audit.server",
-      server: this.server,
-    });
-  }
+  // run() removed — handled by XrayKnowledgeSkillBase
 }
 
 // Run the server if this file is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = new XraySecurityAuditServer();
   server.run().catch(() => {});
 }