0xray 3.1.1 → 3.2.0

package/dist/mcps/processor-pipeline.server.js

@@ -3,14 +3,11 @@
  *
  * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
  */
-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 * as fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { CodexLoader } from "../enforcement/loaders/codex-loader.js";
-class XrayProcessorPipelineServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
     codexLoader;
     codexRules = [];
     codexTerms = [
@@ -25,14 +22,74 @@ class XrayProcessorPipelineServer {
         "Test Coverage >85%",
     ];
     constructor() {
+        super("processor-pipeline", "3.1.0");
         this.codexLoader = new CodexLoader();
-        this.server = new Server({
-            name: "processor-pipeline", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
+        this.tools = [
+            {
+                name: "execute-pre-processors",
+                description: "Run pre-execution processors on content with codex validation",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string" },
+                        context: { type: "object" },
+                        validateCodex: { type: "boolean", default: true },
+                        strictMode: { type: "boolean", default: false },
+                    },
+                    required: ["content"],
+                },
+            },
+            {
+                name: "execute-post-processors",
+                description: "Run post-execution processors on results with compliance monitoring",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string" },
+                        results: { type: "object" },
+                        enforceCompliance: { type: "boolean", default: true },
+                        auditTrail: { type: "boolean", default: true },
+                    },
+                    required: ["content"],
+                },
+            },
+            {
+                name: "codex-validation",
+                description: "Validate content against Universal Development Codex terms",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string" },
+                        terms: {
+                            type: "array",
+                            items: { type: "string" },
+                            default: ["all"],
+                        },
+                        strict: { type: "boolean", default: false },
+                    },
+                    required: ["content"],
+                },
+            },
+            {
+                name: "framework-compliance-check",
+                description: "Check framework compliance and generate enforcement actions",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string" },
+                        operation: { type: "string" },
+                        context: { type: "object" },
+                    },
+                    required: ["content", "operation"],
+                },
             },
-        });
+        ];
+        this.handlers = {
+            "execute-pre-processors": async (args) => this.handlePreProcessors(args),
+            "execute-post-processors": async (args) => this.handlePostProcessors(args),
+            "codex-validation": async (args) => this.handleCodexValidation(args),
+            "framework-compliance-check": async (args) => this.handleComplianceCheck(args),
+        };
         this.setupToolHandlers();
         this.loadCodexRules();
         // Server initialized silently - use frameworkLogger for important events
@@ -48,89 +105,6 @@ class XrayProcessorPipelineServer {
             await frameworkLogger.log("mcps/processor-pipeline", "codex-rules-load-failed", "warning", { message: `Failed to load codex rules: ${error instanceof Error ? error.message : String(error)}` });
         }
     }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "execute-pre-processors",
-                        description: "Run pre-execution processors on content with codex validation",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                content: { type: "string" },
-                                context: { type: "object" },
-                                validateCodex: { type: "boolean", default: true },
-                                strictMode: { type: "boolean", default: false },
-                            },
-                            required: ["content"],
-                        },
-                    },
-                    {
-                        name: "execute-post-processors",
-                        description: "Run post-execution processors on results with compliance monitoring",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                content: { type: "string" },
-                                results: { type: "object" },
-                                enforceCompliance: { type: "boolean", default: true },
-                                auditTrail: { type: "boolean", default: true },
-                            },
-                            required: ["content"],
-                        },
-                    },
-                    {
-                        name: "codex-validation",
-                        description: "Validate content against Universal Development Codex terms",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                content: { type: "string" },
-                                terms: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    default: ["all"],
-                                },
-                                strict: { type: "boolean", default: false },
-                            },
-                            required: ["content"],
-                        },
-                    },
-                    {
-                        name: "framework-compliance-check",
-                        description: "Check framework compliance and generate enforcement actions",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                content: { type: "string" },
-                                operation: { type: "string" },
-                                context: { type: "object" },
-                            },
-                            required: ["content", "operation"],
-                        },
-                    },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "execute-pre-processors":
-                    return await this.handlePreProcessors(args);
-                case "execute-post-processors":
-                    return await this.handlePostProcessors(args);
-                case "codex-validation":
-                    return await this.handleCodexValidation(args);
-                case "framework-compliance-check":
-                    return await this.handleComplianceCheck(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
-    }
     async handlePreProcessors(args) {
         const content = args.content;
         const context = args.context || {};
@@ -548,11 +522,6 @@ ${complianceResults.actions.map((a) => `• 🔧 ${a}`).join("\n") || "None requ
         }
         return results;
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Silent start - no console output
-    }
 }
 // Start the server if run directly
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {

package/dist/mcps/researcher.server.js

@@ -7,122 +7,98 @@
  * NOTE: Class is named XrayLibrarianServer but the MCP server name is
  * "researcher" for backwards compatibility with existing tool references.
  */
-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 * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { tryLLMGovernance } from "../governance/llm-governance-provider.js";
-class XrayLibrarianServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayLibrarianServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "researcher", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "search_codebase",
-                        description: "Search the codebase for specific patterns, functions, or implementations",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                query: {
-                                    type: "string",
-                                    description: "Search query (function name, pattern, keyword)",
-                                },
-                                fileExtension: {
-                                    type: "string",
-                                    description: "File extension to search (e.g., '.ts', '.js')",
-                                    default: ".ts",
-                                },
-                                maxResults: {
-                                    type: "number",
-                                    description: "Maximum number of results to return",
-                                    default: 10,
-                                },
-                            },
-                            required: ["query"],
+        super("researcher", "3.1.0");
+        this.tools = [
+            {
+                name: "search_codebase",
+                description: "Search the codebase for specific patterns, functions, or implementations",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Search query (function name, pattern, keyword)",
                         },
-                    },
-                    {
-                        name: "find_implementation",
-                        description: "Find implementation examples for a specific pattern or feature",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                feature: {
-                                    type: "string",
-                                    description: "Feature name to find implementations for",
-                                },
-                                context: {
-                                    type: "string",
-                                    description: "Additional context (e.g., 'MCP', 'testing', 'agent')",
-                                },
-                            },
-                            required: ["feature"],
+                        fileExtension: {
+                            type: "string",
+                            description: "File extension to search (e.g., '.ts', '.js')",
+                            default: ".ts",
+                        },
+                        maxResults: {
+                            type: "number",
+                            description: "Maximum number of results to return",
+                            default: 10,
                         },
                     },
-                    {
-                        name: "get_documentation",
-                        description: "Get documentation for a specific module, class, or function",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                target: {
-                                    type: "string",
-                                    description: "Module, class, or function name",
-                                },
-                                includeExamples: {
-                                    type: "boolean",
-                                    description: "Include usage examples",
-                                    default: true,
-                                },
-                            },
-                            required: ["target"],
+                    required: ["query"],
+                },
+            },
+            {
+                name: "find_implementation",
+                description: "Find implementation examples for a specific pattern or feature",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        feature: {
+                            type: "string",
+                            description: "Feature name to find implementations for",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Additional context (e.g., 'MCP', 'testing', 'agent')",
                         },
                     },
-                    {
-                        name: "analyze_proposal",
-                        description: "Analyze an inference proposal from a researcher / project-librarian perspective using corpus patterns, historical evidence, and architecture knowledge",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                proposalTitle: { type: "string" },
-                                proposalDescription: { type: "string" },
-                                evidence: { type: "array", items: { type: "string" } },
-                                proposalType: { type: "string" },
-                            },
-                            required: ["proposalTitle", "proposalDescription"],
+                    required: ["feature"],
+                },
+            },
+            {
+                name: "get_documentation",
+                description: "Get documentation for a specific module, class, or function",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        target: {
+                            type: "string",
+                            description: "Module, class, or function name",
+                        },
+                        includeExamples: {
+                            type: "boolean",
+                            description: "Include usage examples",
+                            default: true,
                         },
                     },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "search_codebase":
-                    return await this.searchCodebase(args);
-                case "find_implementation":
-                    return await this.findImplementation(args);
-                case "get_documentation":
-                    return await this.getDocumentation(args);
-                case "analyze_proposal":
-                    return await this.analyzeProposal(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
+                    required: ["target"],
+                },
+            },
+            {
+                name: "analyze_proposal",
+                description: "Analyze an inference proposal from a researcher / project-librarian perspective using corpus patterns, historical evidence, and architecture knowledge",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        proposalTitle: { type: "string" },
+                        proposalDescription: { type: "string" },
+                        evidence: { type: "array", items: { type: "string" } },
+                        proposalType: { type: "string" },
+                    },
+                    required: ["proposalTitle", "proposalDescription"],
+                },
+            },
+        ];
+        this.handlers = {
+            "search_codebase": async (args) => this.searchCodebase(args),
+            "find_implementation": async (args) => this.findImplementation(args),
+            "get_documentation": async (args) => this.getDocumentation(args),
+            "analyze_proposal": async (args) => this.analyzeProposal(args),
+        };
+        this.setupToolHandlers();
     }
     async searchCodebase(args) {
         const { query, fileExtension = ".ts", maxResults = 10 } = args;
@@ -421,55 +397,6 @@ class XrayLibrarianServer {
             ],
         };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        let parentCheckTimer = null;
-        const cleanup = async (signal) => {
-            if (parentCheckTimer !== null) {
-                clearTimeout(parentCheckTimer);
-                parentCheckTimer = null;
-            }
-            const timeout = setTimeout(() => {
-                frameworkLogger.log("mcps/researcher", "shutdown", "error", { message: "Graceful shutdown timeout, forcing exit..." });
-                process.exit(1);
-            }, 5000);
-            try {
-                if (this.server && typeof this.server.close === "function") {
-                    await this.server.close();
-                }
-                clearTimeout(timeout);
-                process.exit(0);
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                frameworkLogger.log("mcps/researcher", "shutdown", "error", { message: `Error during server shutdown: ${String(error)}` });
-                process.exit(1);
-            }
-        };
-        process.on("SIGINT", () => cleanup("SIGINT"));
-        process.on("SIGTERM", () => cleanup("SIGTERM"));
-        process.on("SIGHUP", () => cleanup("SIGHUP"));
-        const checkParent = () => {
-            try {
-                process.kill(process.ppid, 0);
-                parentCheckTimer = setTimeout(checkParent, 1000);
-            }
-            catch (error) {
-                parentCheckTimer = null;
-                cleanup("parent-process-death");
-            }
-        };
-        parentCheckTimer = setTimeout(checkParent, 2000);
-        process.on("uncaughtException", (error) => {
-            frameworkLogger.log("mcps/researcher", "uncaughtException", "error", { message: `Uncaught Exception: ${String(error)}` });
-            cleanup("uncaughtException");
-        });
-        process.on("unhandledRejection", (reason, promise) => {
-            frameworkLogger.log("mcps/researcher", "unhandledRejection", "error", { message: `Unhandled Rejection: ${String(reason)}` });
-            cleanup("unhandledRejection");
-        });
-    }
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {

package/dist/mcps/security-scan.server.js

@@ -3,82 +3,73 @@
  *
  * Automated security vulnerability scanning with dependency and code analysis
  */
-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 { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { execFileSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import { detectProjectLanguage, LANGUAGE_CONFIGS, } from "../utils/language-detector.js";
 import { frameworkLogger } from "../core/framework-logger.js";
-class XraySecurityScanServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XraySecurityScanServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "security-scan", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
+        super("security-scan", "3.1.0");
+        this.tools = [
+            {
+                name: "security-scan",
+                description: "Comprehensive security vulnerability scanning with dependency and code analysis",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        scope: {
+                            type: "string",
+                            enum: ["dependencies", "code", "full"],
+                            default: "full",
+                            description: "Scope of security scan",
+                        },
+                        auditLevel: {
+                            type: "string",
+                            enum: ["info", "low", "moderate", "high", "critical"],
+                            default: "moderate",
+                            description: "Audit level for vulnerability detection",
+                        },
+                        includeOutdated: {
+                            type: "boolean",
+                            default: true,
+                            description: "Include outdated package analysis",
+                        },
+                    },
+                },
             },
-        });
+            {
+                name: "dependency-audit",
+                description: "Audit third-party dependencies for security vulnerabilities",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        packageManager: {
+                            type: "string",
+                            enum: ["npm", "yarn", "pnpm", "auto"],
+                            default: "auto",
+                            description: "Package manager to use",
+                        },
+                        auditLevel: {
+                            type: "string",
+                            enum: ["info", "low", "moderate", "high", "critical"],
+                            default: "moderate",
+                        },
+                    },
+                },
+            },
+        ];
+        this.handlers = {
+            "security-scan": async (args) => this.handleSecurityScan(args),
+            "dependency-audit": async (args) => this.handleDependencyAudit(args),
+        };
         this.setupToolHandlers();
         frameworkLogger.log("mcps/security-scan", "initialize", "info");
     }
     setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "security-scan",
-                        description: "Comprehensive security vulnerability scanning with dependency and code analysis",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                scope: {
-                                    type: "string",
-                                    enum: ["dependencies", "code", "full"],
-                                    default: "full",
-                                    description: "Scope of security scan",
-                                },
-                                auditLevel: {
-                                    type: "string",
-                                    enum: ["info", "low", "moderate", "high", "critical"],
-                                    default: "moderate",
-                                    description: "Audit level for vulnerability detection",
-                                },
-                                includeOutdated: {
-                                    type: "boolean",
-                                    default: true,
-                                    description: "Include outdated package analysis",
-                                },
-                            },
-                        },
-                    },
-                    {
-                        name: "dependency-audit",
-                        description: "Audit third-party dependencies for security vulnerabilities",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                packageManager: {
-                                    type: "string",
-                                    enum: ["npm", "yarn", "pnpm", "auto"],
-                                    default: "auto",
-                                    description: "Package manager to use",
-                                },
-                                auditLevel: {
-                                    type: "string",
-                                    enum: ["info", "low", "moderate", "high", "critical"],
-                                    default: "moderate",
-                                },
-                            },
-                        },
-                    },
-                ],
-            };
-        });
-        // Handle tool calls
+        this.setupListToolsHandler();
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
             try {
@@ -517,11 +508,6 @@ ${results.recommendations.map((r) => `• ${r}`).join("\n") || "No recommendatio
 - Threats: ${threatCount}
 - Recommendations: ${recCount}`;
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        frameworkLogger.log("mcps/security-scan", "start", "info");
-    }
 }
 // Start the server if run directly
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {

package/dist/mcps/shared/knowledge-skill-base.js

@@ -5,13 +5,18 @@ import { frameworkLogger } from "../../core/framework-logger.js";
 import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
 export class XrayKnowledgeSkillBase {
     tools = [];
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handlers = {};
     server;
+    serverName;
     constructor(serverName, version = "2.0.1") {
+        this.serverName = serverName;
         this.server = new Server({ name: serverName, version }, { capabilities: { tools: {} } });
     }
     setupToolHandlers() {
+        this.setupListToolsHandler();
+        this.setupCallToolHandler();
+    }
+    setupListToolsHandler() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
             tools: this.tools.map((t) => ({
                 name: t.name,
@@ -19,6 +24,8 @@ export class XrayKnowledgeSkillBase {
                 inputSchema: t.inputSchema,
             })),
         }));
+    }
+    setupCallToolHandler() {
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
             const handler = this.handlers[name];
@@ -36,10 +43,10 @@ export class XrayKnowledgeSkillBase {
             }
         });
     }
-    async run(serverName) {
+    async run() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        createGracefulShutdown({ serverName, server: this.server });
-        await frameworkLogger.log(serverName, "server-started", "success");
+        createGracefulShutdown({ serverName: this.serverName, server: this.server });
+        await frameworkLogger.log(this.serverName, "server-started", "success");
     }
 }