0xray 3.0.11 → 3.0.14

package/src/mcps/knowledge-skills/database-design.server.ts

@@ -5,11 +5,16 @@
  * query performance analysis, and data modeling best practices
  */
 
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { pluginRegistry } from "../../nucleus/plugin-registry.js";
+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 { createGracefulShutdown } from "../../utils/shutdown-handler.js";
 
 interface DatabaseSchema {
   tables: TableSchema[];
@@ -106,143 +111,166 @@ interface SchemaComparison {
   hasDataLoss: boolean;
 }
 
-class XrayDatabaseDesignServer extends XrayKnowledgeSkillBase {
+class XrayDatabaseDesignServer {
+  private server: Server;
+
   constructor() {
-    super("database-design", "2.0.1");
-    this.tools = [
+    this.server = new Server(
       {
-        name: "analyze_schema",
-        description:
-          "Analyze database schema for optimization opportunities and best practices",
-        inputSchema: {
-          type: "object",
-          properties: {
-            schemaFile: {
-              type: "string",
-              description:
-                "Path to schema definition file (SQL, migration, or ORM model)",
-            },
-            databaseType: {
-              type: "string",
-              enum: ["postgresql", "mysql", "sqlite", "mongodb", "redis"],
-              description: "Database type for specific optimizations",
-            },
-            includeIndexes: {
-              type: "boolean",
-              description: "Include index recommendations in analysis",
-              default: true,
-            },
-          },
-          required: ["schemaFile"],
-        },
+        name: "database-design", version: "1.22.67",
       },
       {
-        name: "optimize_query",
-        description:
-          "Analyze and optimize SQL queries for better performance",
-        inputSchema: {
-          type: "object",
-          properties: {
-            query: {
-              type: "string",
-              description: "SQL query to analyze and optimize",
-            },
-            schemaContext: {
-              type: "string",
-              description:
-                "Schema context or file path for better analysis",
-            },
-            databaseType: {
-              type: "string",
-              enum: ["postgresql", "mysql", "sqlite"],
-              description: "Database type for query optimization",
-            },
-          },
-          required: ["query"],
+        capabilities: {
+          tools: {},
         },
       },
-      {
-        name: "design_data_model",
-        description: "Design optimal data model for given requirements",
-        inputSchema: {
-          type: "object",
-          properties: {
-            requirements: {
-              type: "string",
-              description: "Business requirements and data access patterns",
+    );
+
+    this.setupToolHandlers();
+    // Server initialization - removed unnecessary startup logging
+  }
+
+  private setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "analyze_schema",
+            description:
+              "Analyze database schema for optimization opportunities and best practices",
+            inputSchema: {
+              type: "object",
+              properties: {
+                schemaFile: {
+                  type: "string",
+                  description:
+                    "Path to schema definition file (SQL, migration, or ORM model)",
+                },
+                databaseType: {
+                  type: "string",
+                  enum: ["postgresql", "mysql", "sqlite", "mongodb", "redis"],
+                  description: "Database type for specific optimizations",
+                },
+                includeIndexes: {
+                  type: "boolean",
+                  description: "Include index recommendations in analysis",
+                  default: true,
+                },
+              },
+              required: ["schemaFile"],
             },
-            entities: {
-              type: "array",
-              items: { type: "string" },
-              description: "List of main entities/business objects",
+          },
+          {
+            name: "optimize_query",
+            description:
+              "Analyze and optimize SQL queries for better performance",
+            inputSchema: {
+              type: "object",
+              properties: {
+                query: {
+                  type: "string",
+                  description: "SQL query to analyze and optimize",
+                },
+                schemaContext: {
+                  type: "string",
+                  description:
+                    "Schema context or file path for better analysis",
+                },
+                databaseType: {
+                  type: "string",
+                  enum: ["postgresql", "mysql", "sqlite"],
+                  description: "Database type for query optimization",
+                },
+              },
+              required: ["query"],
             },
-            relationships: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  from: { type: "string" },
-                  to: { type: "string" },
-                  type: {
-                    type: "string",
-                    enum: ["one-to-one", "one-to-many", "many-to-many"],
+          },
+          {
+            name: "design_data_model",
+            description: "Design optimal data model for given requirements",
+            inputSchema: {
+              type: "object",
+              properties: {
+                requirements: {
+                  type: "string",
+                  description: "Business requirements and data access patterns",
+                },
+                entities: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "List of main entities/business objects",
+                },
+                relationships: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      from: { type: "string" },
+                      to: { type: "string" },
+                      type: {
+                        type: "string",
+                        enum: ["one-to-one", "one-to-many", "many-to-many"],
+                      },
+                    },
                   },
+                  description: "Entity relationships",
+                },
+                databaseType: {
+                  type: "string",
+                  enum: ["postgresql", "mysql", "mongodb", "redis"],
+                  description: "Target database type",
                 },
               },
-              description: "Entity relationships",
-            },
-            databaseType: {
-              type: "string",
-              enum: ["postgresql", "mysql", "mongodb", "redis"],
-              description: "Target database type",
+              required: ["requirements", "entities"],
             },
           },
-          required: ["requirements", "entities"],
-        },
-      },
-      {
-        name: "migrate_schema",
-        description: "Generate migration scripts for schema changes",
-        inputSchema: {
-          type: "object",
-          properties: {
-            currentSchema: {
-              type: "string",
-              description: "Current schema definition",
-            },
-            targetSchema: {
-              type: "string",
-              description: "Target schema definition",
-            },
-            databaseType: {
-              type: "string",
-              enum: ["postgresql", "mysql", "sqlite"],
-              description: "Database type for migration",
-            },
-            safeMode: {
-              type: "boolean",
-              description: "Generate rollback scripts and safety checks",
-              default: true,
+          {
+            name: "migrate_schema",
+            description: "Generate migration scripts for schema changes",
+            inputSchema: {
+              type: "object",
+              properties: {
+                currentSchema: {
+                  type: "string",
+                  description: "Current schema definition",
+                },
+                targetSchema: {
+                  type: "string",
+                  description: "Target schema definition",
+                },
+                databaseType: {
+                  type: "string",
+                  enum: ["postgresql", "mysql", "sqlite"],
+                  description: "Database type for migration",
+                },
+                safeMode: {
+                  type: "boolean",
+                  description: "Generate rollback scripts and safety checks",
+                  default: true,
+                },
+              },
+              required: ["currentSchema", "targetSchema"],
             },
           },
-          required: ["currentSchema", "targetSchema"],
-        },
-      },
-    ];
-    this.handlers = {
-      "analyze_schema": async (args) => this.analyzeSchema(args as Record<string, unknown> | undefined),
-      "optimize_query": async (args) => this.optimizeQuery(args as Record<string, unknown> | undefined),
-      "design_data_model": async (args) => this.designDataModel(args as Record<string, unknown> | undefined),
-      "migrate_schema": async (args) => this.migrateSchema(args as Record<string, unknown> | undefined),
-    };
-    this.setupToolHandlers();
-    pluginRegistry.registerToolPlugin({
-      name: "database-design",
-      callTool: async (toolName, args) => {
-        const handler = this.handlers[toolName];
-        if (!handler) throw new Error(`Unknown tool: ${toolName}`);
-        return handler(args);
-      },
+        ],
+      };
+    });
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      switch (name) {
+        case "analyze_schema":
+          return await this.analyzeSchema(args);
+        case "optimize_query":
+          return await this.optimizeQuery(args);
+        case "design_data_model":
+          return await this.designDataModel(args);
+        case "migrate_schema":
+          return await this.migrateSchema(args);
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
     });
   }
 
@@ -1151,12 +1179,22 @@ class XrayDatabaseDesignServer extends XrayKnowledgeSkillBase {
     return icons[severity as keyof typeof icons] || "❓";
   }
 
+  async run(): Promise<void> {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    
+    // Use centralized shutdown handler
+    createGracefulShutdown({
+      serverName: "database-design.server",
+      server: this.server,
+    });
+  }
 }
 
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayDatabaseDesignServer();
-  server.run("database-design").catch((err) => { frameworkLogger.log("database-design", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
+  server.run().catch(() => {});
 }
 
 export { XrayDatabaseDesignServer };

package/src/mcps/knowledge-skills/devops-deployment.server.ts

@@ -5,9 +5,14 @@
  * CI/CD pipeline design, and infrastructure automation
  */
 
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
-import { pluginRegistry } from "../../nucleus/plugin-registry.js";
+import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
 
 interface DeploymentStrategy {
   name: string;
@@ -201,95 +206,176 @@ interface OptimizationRoadmap {
   finalMetrics: DeploymentMetricsInput;
 }
 
-class XrayDevOpsDeploymentServer extends XrayKnowledgeSkillBase {
+class XrayDevOpsDeploymentServer {
+  private server: Server;
 
   constructor() {
-    super("devops-deployment", "2.0.1");
-    this.tools = [
+    this.server = new Server(
       {
-        name: "analyze_ci_cd_pipeline",
-        description: "Analyze CI/CD pipeline configuration and suggest optimizations",
-        inputSchema: {
-          type: "object",
-          properties: {
-            pipelineConfig: { type: "string", description: "CI/CD pipeline configuration (YAML/JSON)" },
-            platform: { type: "string", enum: ["github-actions", "gitlab-ci", "jenkins", "circle-ci", "azure-devops"], description: "CI/CD platform being used" },
-            includeSecurity: { type: "boolean", description: "Include security gate analysis", default: true },
-          },
-          required: ["pipelineConfig", "platform"],
-        },
+        name: "devops-deployment", version: "1.22.67",
       },
       {
-        name: "design_deployment_strategy",
-        description: "Design optimal deployment strategy for application requirements",
-        inputSchema: {
-          type: "object",
-          properties: {
-            applicationType: { type: "string", enum: ["web-app", "api", "mobile", "microservices", "monolith"], description: "Type of application" },
-            scale: { type: "string", enum: ["small", "medium", "large", "enterprise"], description: "Expected scale/traffic" },
-            availability: { type: "string", enum: ["basic", "high", "critical"], description: "Required availability level" },
-            budget: { type: "string", enum: ["cost-optimized", "balanced", "performance-optimized"], description: "Budget considerations" },
-          },
-          required: ["applicationType", "scale"],
+        capabilities: {
+          tools: {},
         },
       },
-      {
-        name: "generate_infrastructure_code",
-        description: "Generate infrastructure as code for deployment",
-        inputSchema: {
-          type: "object",
-          properties: {
-            platform: { type: "string", enum: ["aws", "azure", "gcp", "kubernetes"], description: "Target cloud platform" },
-            services: { type: "array", items: { type: "string" }, description: "Required services (database, cache, storage, etc.)" },
-            environment: { type: "string", enum: ["development", "staging", "production"], description: "Deployment environment" },
-            scaling: { type: "boolean", description: "Include auto-scaling configuration", default: true },
+    );
+
+    this.setupToolHandlers();
+    // Server initialization - removed unnecessary startup logging
+  }
+
+  private setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "analyze_ci_cd_pipeline",
+            description:
+              "Analyze CI/CD pipeline configuration and suggest optimizations",
+            inputSchema: {
+              type: "object",
+              properties: {
+                pipelineConfig: {
+                  type: "string",
+                  description: "CI/CD pipeline configuration (YAML/JSON)",
+                },
+                platform: {
+                  type: "string",
+                  enum: [
+                    "github-actions",
+                    "gitlab-ci",
+                    "jenkins",
+                    "circle-ci",
+                    "azure-devops",
+                  ],
+                  description: "CI/CD platform being used",
+                },
+                includeSecurity: {
+                  type: "boolean",
+                  description: "Include security gate analysis",
+                  default: true,
+                },
+              },
+              required: ["pipelineConfig", "platform"],
+            },
           },
-          required: ["platform", "services"],
-        },
-      },
-      {
-        name: "optimize_deployment_performance",
-        description: "Analyze and optimize deployment performance and reliability",
-        inputSchema: {
-          type: "object",
-          properties: {
-            currentMetrics: {
+          {
+            name: "design_deployment_strategy",
+            description:
+              "Design optimal deployment strategy for application requirements",
+            inputSchema: {
               type: "object",
               properties: {
-                deployTime: { type: "number" },
-                failureRate: { type: "number" },
-                rollbackTime: { type: "number" },
+                applicationType: {
+                  type: "string",
+                  enum: [
+                    "web-app",
+                    "api",
+                    "mobile",
+                    "microservices",
+                    "monolith",
+                  ],
+                  description: "Type of application",
+                },
+                scale: {
+                  type: "string",
+                  enum: ["small", "medium", "large", "enterprise"],
+                  description: "Expected scale/traffic",
+                },
+                availability: {
+                  type: "string",
+                  enum: ["basic", "high", "critical"],
+                  description: "Required availability level",
+                },
+                budget: {
+                  type: "string",
+                  enum: ["cost-optimized", "balanced", "performance-optimized"],
+                  description: "Budget considerations",
+                },
               },
-              description: "Current deployment metrics",
+              required: ["applicationType", "scale"],
             },
-            constraints: {
+          },
+          {
+            name: "generate_infrastructure_code",
+            description: "Generate infrastructure as code for deployment",
+            inputSchema: {
               type: "object",
               properties: {
-                maxDowntime: { type: "number" },
-                budget: { type: "number" },
-                teamSize: { type: "number" },
+                platform: {
+                  type: "string",
+                  enum: ["aws", "azure", "gcp", "kubernetes"],
+                  description: "Target cloud platform",
+                },
+                services: {
+                  type: "array",
+                  items: { type: "string" },
+                  description:
+                    "Required services (database, cache, storage, etc.)",
+                },
+                environment: {
+                  type: "string",
+                  enum: ["development", "staging", "production"],
+                  description: "Deployment environment",
+                },
+                scaling: {
+                  type: "boolean",
+                  description: "Include auto-scaling configuration",
+                  default: true,
+                },
               },
-              description: "Business and technical constraints",
+              required: ["platform", "services"],
             },
           },
-          required: ["currentMetrics"],
-        },
-      },
-    ];
-    this.handlers = {
-      "analyze_ci_cd_pipeline": async (args) => this.analyzeCICDPipeline(args as unknown as CICDPipelineArgs),
-      "design_deployment_strategy": async (args) => this.designDeploymentStrategy(args as unknown as DeploymentStrategyArgs),
-      "generate_infrastructure_code": async (args) => this.generateInfrastructureCode(args as unknown as InfrastructureCodeArgs),
-      "optimize_deployment_performance": async (args) => this.optimizeDeploymentPerformance(args as unknown as DeploymentPerformanceArgs),
-    };
-    this.setupToolHandlers();
-    pluginRegistry.registerToolPlugin({
-      name: "devops-deployment",
-      callTool: async (toolName, args) => {
-        const handler = this.handlers[toolName];
-        if (!handler) throw new Error(`Unknown tool: ${toolName}`);
-        return handler(args);
-      },
+          {
+            name: "optimize_deployment_performance",
+            description:
+              "Analyze and optimize deployment performance and reliability",
+            inputSchema: {
+              type: "object",
+              properties: {
+                currentMetrics: {
+                  type: "object",
+                  properties: {
+                    deployTime: { type: "number" },
+                    failureRate: { type: "number" },
+                    rollbackTime: { type: "number" },
+                  },
+                  description: "Current deployment metrics",
+                },
+                constraints: {
+                  type: "object",
+                  properties: {
+                    maxDowntime: { type: "number" },
+                    budget: { type: "number" },
+                    teamSize: { type: "number" },
+                  },
+                  description: "Business and technical constraints",
+                },
+              },
+              required: ["currentMetrics"],
+            },
+          },
+        ],
+      };
+    });
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      switch (name) {
+        case "analyze_ci_cd_pipeline":
+          return await this.analyzeCICDPipeline(args as unknown as CICDPipelineArgs);
+        case "design_deployment_strategy":
+          return await this.designDeploymentStrategy(args as unknown as DeploymentStrategyArgs);
+        case "generate_infrastructure_code":
+          return await this.generateInfrastructureCode(args as unknown as InfrastructureCodeArgs);
+        case "optimize_deployment_performance":
+          return await this.optimizeDeploymentPerformance(args as unknown as DeploymentPerformanceArgs);
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
     });
   }
 
@@ -1515,12 +1601,22 @@ spec:
     }
   }
 
+  async run(): Promise<void> {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    
+    // Use centralized shutdown handler
+    createGracefulShutdown({
+      serverName: "devops-deployment.server",
+      server: this.server,
+    });
+  }
 }
 
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayDevOpsDeploymentServer();
-  server.run("devops-deployment").catch((err) => { frameworkLogger.log("devops-deployment", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
+  server.run().catch(() => {});
 }
 
 export { XrayDevOpsDeploymentServer };