0xray 3.1.1 → 3.2.0

package/src/mcps/researcher.server.ts

@@ -8,17 +8,12 @@
  * "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,
-  type CallToolResult,
-} from "@modelcontextprotocol/sdk/types.js";
+import { 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 { tryLLMGovernance } from "../governance/llm-governance-provider.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface SearchResult {
   file: string;
@@ -49,128 +44,101 @@ interface AnalyzeProposalArgs {
   proposalType?: string;
 }
 
-class XrayLibrarianServer {
-  private server: Server;
-
+class XrayLibrarianServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
-      {
-        name: "researcher", version: "3.1.0",
-      },
+    super("researcher", "3.1.0");
+
+    this.tools = [
       {
-        capabilities: {
-          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"],
         },
       },
-    );
-
-    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"],
+      {
+        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",
             },
-          },
-          {
-            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"],
+            context: {
+              type: "string",
+              description:
+                "Additional context (e.g., 'MCP', 'testing', 'agent')",
             },
           },
-          {
-            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: ["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",
             },
-          },
-          {
-            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"],
+            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 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}`);
-      }
-    });
+          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 as SearchCodebaseArgs),
+      "find_implementation": async (args) => this.findImplementation(args as FindImplementationArgs),
+      "get_documentation": async (args) => this.getDocumentation(args as GetDocumentationArgs),
+      "analyze_proposal": async (args) => this.analyzeProposal(args as AnalyzeProposalArgs),
+    };
+
+    this.setupToolHandlers();
   }
 
   private async searchCodebase(args: SearchCodebaseArgs) {
@@ -513,62 +481,6 @@ class XrayLibrarianServer {
     };
   }
 
-  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

package/src/mcps/security-scan.server.ts

@@ -4,12 +4,7 @@
  * 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";
@@ -19,6 +14,7 @@ import {
   type LanguageConfig,
 } from "../utils/language-detector.js";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface SecurityScanArgs {
   scope?: string;
@@ -39,83 +35,73 @@ interface SecuritySummaryResults {
   summary: string;
 }
 
-class XraySecurityScanServer {
-  private server: Server;
-
+class XraySecurityScanServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
+    super("security-scan", "3.1.0");
+
+    this.tools = [
       {
-        name: "security-scan", version: "3.1.0",
+        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",
+            },
+          },
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        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");
   }
 
-  private 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",
-                },
-              },
-            },
-          },
-        ],
-      };
-    });
+  protected override setupToolHandlers(): void {
+    this.setupListToolsHandler();
 
-    // Handle tool calls
     this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
       const { name, arguments: args } = request.params;
 
@@ -635,11 +621,6 @@ ${results.recommendations.map((r) => `• ${r}`).join("\n") || "No recommendatio
 - 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

package/src/mcps/shared/knowledge-skill-base.ts

@@ -15,12 +15,13 @@ export interface ToolDefinition {
 
 export class XrayKnowledgeSkillBase {
   protected tools: ToolDefinition[] = [];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   protected handlers: Record<string, (args: unknown) => Promise<any>> = {};
 
   protected server: Server;
+  protected serverName: string;
 
   constructor(serverName: string, version = "2.0.1") {
+    this.serverName = serverName;
     this.server = new Server(
       { name: serverName, version },
       { capabilities: { tools: {} } },
@@ -28,6 +29,11 @@ export class XrayKnowledgeSkillBase {
   }
 
   protected setupToolHandlers(): void {
+    this.setupListToolsHandler();
+    this.setupCallToolHandler();
+  }
+
+  protected setupListToolsHandler(): void {
     this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
       tools: this.tools.map((t) => ({
         name: t.name,
@@ -35,7 +41,9 @@ export class XrayKnowledgeSkillBase {
         inputSchema: t.inputSchema,
       })),
     }));
+  }
 
+  protected setupCallToolHandler(): void {
     this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
       const { name, arguments: args } = request.params;
       const handler = this.handlers[name];
@@ -53,10 +61,10 @@ export class XrayKnowledgeSkillBase {
     });
   }
 
-  async run(serverName: string): Promise<void> {
+  async run(): Promise<void> {
     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");
   }
 }