0xray 2.1.1 → 2.1.3

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

@@ -5,16 +5,10 @@
  * query performance analysis, and data modeling best practices
  */
 
-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 { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.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[];
@@ -111,167 +105,136 @@ interface SchemaComparison {
   hasDataLoss: boolean;
 }
 
-class XrayDatabaseDesignServer {
-  private server: Server;
-
+class XrayDatabaseDesignServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
+    super("database-design", "2.0.1");
+    this.tools = [
       {
-        name: "database-design", version: "2.0.1",
+        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"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        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"],
         },
       },
-    );
-
-    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"],
+      {
+        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",
             },
-          },
-          {
-            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"],
+            entities: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of main entities/business objects",
             },
-          },
-          {
-            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"],
-                      },
-                    },
+            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",
                 },
               },
-              required: ["requirements", "entities"],
+              description: "Entity relationships",
+            },
+            databaseType: {
+              type: "string",
+              enum: ["postgresql", "mysql", "mongodb", "redis"],
+              description: "Target database type",
             },
           },
-          {
-            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: ["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,
             },
           },
-        ],
-      };
-    });
-
-    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}`);
-      }
-    });
+          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();
   }
 
   private async analyzeSchema(args: Record<string, unknown> | undefined) {
@@ -1179,22 +1142,12 @@ class XrayDatabaseDesignServer {
     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().catch(() => {});
+  server.run("database-design").catch((err) => { frameworkLogger.log("database-design", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 
 export { XrayDatabaseDesignServer };

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

@@ -5,14 +5,8 @@
  * CI/CD pipeline design, and infrastructure automation
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
 
 interface DeploymentStrategy {
   name: string;
@@ -206,177 +200,88 @@ interface OptimizationRoadmap {
   finalMetrics: DeploymentMetricsInput;
 }
 
-class XrayDevOpsDeploymentServer {
-  private server: Server;
+class XrayDevOpsDeploymentServer extends XrayKnowledgeSkillBase {
 
   constructor() {
-    this.server = new Server(
+    super("devops-deployment", "2.0.1");
+    this.tools = [
       {
-        name: "devops-deployment", version: "2.0.1",
+        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"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        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"],
         },
       },
-    );
-
-    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"],
-            },
-          },
-          {
-            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"],
-            },
+      {
+        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 },
           },
-          {
-            name: "generate_infrastructure_code",
-            description: "Generate infrastructure as code for deployment",
-            inputSchema: {
+          required: ["platform", "services"],
+        },
+      },
+      {
+        name: "optimize_deployment_performance",
+        description: "Analyze and optimize deployment performance and reliability",
+        inputSchema: {
+          type: "object",
+          properties: {
+            currentMetrics: {
               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,
-                },
+                deployTime: { type: "number" },
+                failureRate: { type: "number" },
+                rollbackTime: { type: "number" },
               },
-              required: ["platform", "services"],
+              description: "Current deployment metrics",
             },
-          },
-          {
-            name: "optimize_deployment_performance",
-            description:
-              "Analyze and optimize deployment performance and reliability",
-            inputSchema: {
+            constraints: {
               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",
-                },
+                maxDowntime: { type: "number" },
+                budget: { type: "number" },
+                teamSize: { type: "number" },
               },
-              required: ["currentMetrics"],
+              description: "Business and technical constraints",
             },
           },
-        ],
-      };
-    });
-
-    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}`);
-      }
-    });
+          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();
   }
 
   private async analyzeCICDPipeline(args: CICDPipelineArgs) {
@@ -1601,22 +1506,12 @@ 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().catch(() => {});
+  server.run("devops-deployment").catch((err) => { frameworkLogger.log("devops-deployment", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 
 export { XrayDevOpsDeploymentServer };