0xray 3.0.11 → 3.0.14

package/dist/mcps/knowledge-skills/database-design.server.js

@@ -4,145 +4,160 @@
  * Knowledge skill for database architecture, schema optimization,
  * 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";
-class XrayDatabaseDesignServer extends XrayKnowledgeSkillBase {
+import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
+class XrayDatabaseDesignServer {
+    server;
     constructor() {
-        super("database-design", "2.0.1");
-        this.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"],
-                },
+        this.server = new Server({
+            name: "database-design", version: "1.22.67",
+        }, {
+            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",
+        });
+        this.setupToolHandlers();
+        // Server initialization - removed unnecessary startup logging
+    }
+    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"],
                         },
                     },
-                    required: ["query"],
-                },
-            },
-            {
-                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",
+                    {
+                        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),
-            "optimize_query": async (args) => this.optimizeQuery(args),
-            "design_data_model": async (args) => this.designDataModel(args),
-            "migrate_schema": async (args) => this.migrateSchema(args),
-        };
-        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}`);
+            }
         });
     }
     async analyzeSchema(args) {
@@ -789,11 +804,19 @@ class XrayDatabaseDesignServer extends XrayKnowledgeSkillBase {
         };
         return icons[severity] || "❓";
     }
+    async run() {
+        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 };
-//# sourceMappingURL=database-design.server.js.map

package/dist/mcps/knowledge-skills/devops-deployment.server.js

@@ -4,98 +4,168 @@
  * Knowledge skill for DevOps practices, deployment strategies,
  * CI/CD pipeline design, and infrastructure automation
  */
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { pluginRegistry } from "../../nucleus/plugin-registry.js";
-class XrayDevOpsDeploymentServer extends XrayKnowledgeSkillBase {
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+class XrayDevOpsDeploymentServer {
+    server;
     constructor() {
-        super("devops-deployment", "2.0.1");
-        this.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"],
-                },
+        this.server = new Server({
+            name: "devops-deployment", version: "1.22.67",
+        }, {
+            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" },
+        });
+        this.setupToolHandlers();
+        // Server initialization - removed unnecessary startup logging
+    }
+    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: ["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: "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"],
+                        },
                     },
-                    required: ["platform", "services"],
-                },
-            },
-            {
-                name: "optimize_deployment_performance",
-                description: "Analyze and optimize deployment performance and reliability",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        currentMetrics: {
+                    {
+                        name: "generate_infrastructure_code",
+                        description: "Generate infrastructure as code for deployment",
+                        inputSchema: {
                             type: "object",
                             properties: {
-                                deployTime: { type: "number" },
-                                failureRate: { type: "number" },
-                                rollbackTime: { 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: "Current deployment metrics",
+                            required: ["platform", "services"],
                         },
-                        constraints: {
+                    },
+                    {
+                        name: "optimize_deployment_performance",
+                        description: "Analyze and optimize deployment performance and reliability",
+                        inputSchema: {
                             type: "object",
                             properties: {
-                                maxDowntime: { type: "number" },
-                                budget: { type: "number" },
-                                teamSize: { type: "number" },
+                                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",
+                                },
                             },
-                            description: "Business and technical constraints",
+                            required: ["currentMetrics"],
                         },
                     },
-                    required: ["currentMetrics"],
-                },
-            },
-        ];
-        this.handlers = {
-            "analyze_ci_cd_pipeline": async (args) => this.analyzeCICDPipeline(args),
-            "design_deployment_strategy": async (args) => this.designDeploymentStrategy(args),
-            "generate_infrastructure_code": async (args) => this.generateInfrastructureCode(args),
-            "optimize_deployment_performance": async (args) => this.optimizeDeploymentPerformance(args),
-        };
-        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);
-            },
+                ],
+            };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            switch (name) {
+                case "analyze_ci_cd_pipeline":
+                    return await this.analyzeCICDPipeline(args);
+                case "design_deployment_strategy":
+                    return await this.designDeploymentStrategy(args);
+                case "generate_infrastructure_code":
+                    return await this.generateInfrastructureCode(args);
+                case "optimize_deployment_performance":
+                    return await this.optimizeDeploymentPerformance(args);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
         });
     }
     async analyzeCICDPipeline(args) {
@@ -1092,11 +1162,19 @@ spec:
                 return "json";
         }
     }
+    async run() {
+        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 };
-//# sourceMappingURL=devops-deployment.server.js.map