0xray 3.0.11 → 3.0.14

package/src/mcps/processor-pipeline.server.ts

@@ -4,10 +4,15 @@
  * 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 { frameworkLogger } from "../core/framework-logger.js";
 import { CodexLoader } from "../enforcement/loaders/codex-loader.js";
 import type { RuleDefinition, RuleValidationContext } from "../enforcement/types.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface PreProcessorArgs {
   content: string;
@@ -82,7 +87,8 @@ interface FrameworkComplianceResult {
   approved: boolean;
 }
 
-class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
+class XrayProcessorPipelineServer {
+  private server: Server;
   private codexLoader: CodexLoader;
   private codexRules: RuleDefinition[] = [];
   private codexTerms: string[] = [
@@ -98,81 +104,17 @@ class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
   ];
 
   constructor() {
-    super("processor-pipeline", "2.0.1");
-
     this.codexLoader = new CodexLoader();
-
-    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"],
-        },
-      },
+    this.server = new Server(
       {
-        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: "processor-pipeline", version: "1.22.67",
       },
       {
-        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"],
+        capabilities: {
+          tools: {},
         },
       },
-      {
-        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 as unknown as PreProcessorArgs),
-      "execute-post-processors": async (args) => this.handlePostProcessors(args as unknown as PostProcessorArgs),
-      "codex-validation": async (args) => this.handleCodexValidation(args as unknown as CodexValidationArgs),
-      "framework-compliance-check": async (args) => this.handleComplianceCheck(args as unknown as ComplianceCheckArgs),
-    };
+    );
 
     this.setupToolHandlers();
     this.loadCodexRules();
@@ -200,6 +142,96 @@ class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
     }
   }
 
+  private 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 as unknown as PreProcessorArgs);
+        case "execute-post-processors":
+          return await this.handlePostProcessors(args as unknown as PostProcessorArgs);
+        case "codex-validation":
+          return await this.handleCodexValidation(args as unknown as CodexValidationArgs);
+        case "framework-compliance-check":
+          return await this.handleComplianceCheck(args as unknown as ComplianceCheckArgs);
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    });
+  }
+
   private async handlePreProcessors(args: PreProcessorArgs) {
     const content = args.content;
     const context = args.context || {};
@@ -729,12 +761,18 @@ ${complianceResults.actions.map((a: string) => `• 🔧 ${a}`).join("\n") || "N
 
     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://${process.argv[1]}`) {
   const server = new XrayProcessorPipelineServer();
-  server.run("processor-pipeline").catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
 }
 
 export { XrayProcessorPipelineServer };

package/src/mcps/registry.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.10",
+  "version": "1.22.67",
   "description": "0xRay Community MCPs Registry - curated API-focused MCP servers",
   "sources": [
     {

package/src/mcps/researcher.server.ts

@@ -8,11 +8,16 @@
  * "researcher" for backwards compatibility with existing tool references.
  */
 
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+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 SearchResult {
   file: string;
@@ -43,101 +48,128 @@ interface AnalyzeProposalArgs {
   proposalType?: string;
 }
 
-class XrayLibrarianServer extends XrayKnowledgeSkillBase {
-  constructor() {
-    super("researcher", "2.0.1");
+class XrayLibrarianServer {
+  private server: Server;
 
-    this.tools = [
+  constructor() {
+    this.server = new Server(
       {
-        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"],
-        },
+        name: "researcher", version: "1.22.67",
       },
       {
-        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"],
+        capabilities: {
+          tools: {},
         },
       },
-      {
-        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",
+    );
+
+    this.setupToolHandlers();
+  }
+
+  private 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"],
             },
-            includeExamples: {
-              type: "boolean",
-              description: "Include usage examples",
-              default: true,
+          },
+          {
+            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"],
             },
           },
-          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" },
+          {
+            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: ["proposalTitle", "proposalDescription"],
-        },
-      },
-    ];
-
-    this.handlers = {
-      "search_codebase": async (args) => this.searchCodebase(args as unknown as SearchCodebaseArgs),
-      "find_implementation": async (args) => this.findImplementation(args as unknown as FindImplementationArgs),
-      "get_documentation": async (args) => this.getDocumentation(args as unknown as GetDocumentationArgs),
-      "analyze_proposal": async (args) => this.analyzeProposal(args as unknown as AnalyzeProposalArgs),
-    };
-
-    this.setupToolHandlers();
+          {
+            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.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      switch (name) {
+        case "search_codebase":
+          return await this.searchCodebase(args as unknown as SearchCodebaseArgs);
+        case "find_implementation":
+          return await this.findImplementation(args as unknown as FindImplementationArgs);
+        case "get_documentation":
+          return await this.getDocumentation(args as unknown as GetDocumentationArgs);
+        case "analyze_proposal":
+          return await this.analyzeProposal(args as AnalyzeProposalArgs) as CallToolResult;
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    });
   }
 
   private async searchCodebase(args: SearchCodebaseArgs) {
@@ -495,12 +527,69 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
       ],
     };
   }
+
+  async run(): Promise<void> {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+
+    let parentCheckTimer: ReturnType<typeof setTimeout> | null = null;
+
+    const cleanup = async (signal: string) => {
+      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://${process.argv[1]}`) {
   const server = new XrayLibrarianServer();
-  server.run("researcher").catch((error) => frameworkLogger.log("mcps/researcher", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/researcher", "run", "error", { error: String(error) }));
 }
 
 export { XrayLibrarianServer };