0xray 2.1.2 → 2.1.4

package/dist/mcps/knowledge-skills/security-audit.server.js

@@ -4,144 +4,119 @@
  * Knowledge skill for comprehensive security analysis, vulnerability assessment,
  * and compliance validation - ensures production-ready security posture
  */
-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 { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class XraySecurityAuditServer {
-    server;
+class XraySecurityAuditServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "security-audit", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "audit_security",
-                        description: "Perform comprehensive security audit on codebase files",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                files: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "List of file paths to audit",
-                                },
-                                includeDependencies: {
-                                    type: "boolean",
-                                    description: "Include dependency vulnerability analysis",
-                                    default: true,
-                                },
-                                complianceFrameworks: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: ["owasp-top-10", "nist", "iso-27001", "pci-dss"],
-                                    },
-                                    description: "Compliance frameworks to check against",
-                                },
-                            },
-                            required: ["files"],
+        super("security-audit", "2.0.1");
+        this.tools = [
+            {
+                name: "audit_security",
+                description: "Perform comprehensive security audit on codebase files",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "List of file paths to audit",
                         },
-                    },
-                    {
-                        name: "check_vulnerability",
-                        description: "Check specific security vulnerability patterns in a file",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                filePath: {
-                                    type: "string",
-                                    description: "Path to the file to check",
-                                },
-                                vulnerabilityType: {
-                                    type: "string",
-                                    enum: [
-                                        "injection",
-                                        "authentication",
-                                        "authorization",
-                                        "cryptography",
-                                        "xss",
-                                        "csrf",
-                                        "secrets",
-                                        "configuration",
-                                    ],
-                                },
-                                severity: {
-                                    type: "string",
-                                    enum: ["critical", "high", "medium", "low", "info"],
-                                    description: "Minimum severity level to report",
-                                },
+                        includeDependencies: {
+                            type: "boolean",
+                            description: "Include dependency vulnerability analysis",
+                            default: true,
+                        },
+                        complianceFrameworks: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: ["owasp-top-10", "nist", "iso-27001", "pci-dss"],
                             },
-                            required: ["filePath", "vulnerabilityType"],
+                            description: "Compliance frameworks to check against",
                         },
                     },
-                    {
-                        name: "generate_security_report",
-                        description: "Generate comprehensive security report with remediation steps",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                auditResults: {
-                                    type: "object",
-                                    description: "Results from audit_security tool",
-                                },
-                                format: {
-                                    type: "string",
-                                    enum: ["markdown", "json", "html"],
-                                    default: "markdown",
-                                },
-                                includeRemediation: {
-                                    type: "boolean",
-                                    default: true,
-                                },
-                            },
-                            required: ["auditResults"],
+                    required: ["files"],
+                },
+            },
+            {
+                name: "check_vulnerability",
+                description: "Check specific security vulnerability patterns in a file",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        filePath: {
+                            type: "string",
+                            description: "Path to the file to check",
+                        },
+                        vulnerabilityType: {
+                            type: "string",
+                            enum: [
+                                "injection",
+                                "authentication",
+                                "authorization",
+                                "cryptography",
+                                "xss",
+                                "csrf",
+                                "secrets",
+                                "configuration",
+                            ],
+                        },
+                        severity: {
+                            type: "string",
+                            enum: ["critical", "high", "medium", "low", "info"],
+                            description: "Minimum severity level to report",
                         },
                     },
-                    {
-                        name: "analyze_proposal",
-                        description: "Analyze an inference proposal (pattern/bug/refactor) from a security perspective and return a structured governance decision",
-                        inputSchema: {
+                    required: ["filePath", "vulnerabilityType"],
+                },
+            },
+            {
+                name: "generate_security_report",
+                description: "Generate comprehensive security report with remediation steps",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        auditResults: {
                             type: "object",
-                            properties: {
-                                proposalTitle: { type: "string" },
-                                proposalDescription: { type: "string" },
-                                evidence: { type: "array", items: { type: "string" } },
-                                proposalType: { type: "string" },
-                            },
-                            required: ["proposalTitle", "proposalDescription"],
+                            description: "Results from audit_security tool",
+                        },
+                        format: {
+                            type: "string",
+                            enum: ["markdown", "json", "html"],
+                            default: "markdown",
+                        },
+                        includeRemediation: {
+                            type: "boolean",
+                            default: true,
                         },
                     },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "audit_security":
-                    return await this.auditSecurity(args);
-                case "check_vulnerability":
-                    return await this.checkVulnerability(args);
-                case "generate_security_report":
-                    return await this.generateSecurityReport(args);
-                case "analyze_proposal":
-                    return await this.analyzeProposal(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
+                    required: ["auditResults"],
+                },
+            },
+            {
+                name: "analyze_proposal",
+                description: "Analyze an inference proposal (pattern/bug/refactor) from a security perspective and return a structured governance decision",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        proposalTitle: { type: "string" },
+                        proposalDescription: { type: "string" },
+                        evidence: { type: "array", items: { type: "string" } },
+                        proposalType: { type: "string" },
+                    },
+                    required: ["proposalTitle", "proposalDescription"],
+                },
+            },
+        ];
+        this.handlers = {
+            "audit_security": async (args) => this.auditSecurity(args),
+            "check_vulnerability": async (args) => this.checkVulnerability(args),
+            "generate_security_report": async (args) => this.generateSecurityReport(args),
+            "analyze_proposal": async (args) => this.analyzeProposal(args),
+        };
+        this.setupToolHandlers();
     }
     async auditSecurity(args) {
         const { files, includeDependencies = true, complianceFrameworks = ["owasp-top-10"], } = args;
@@ -828,19 +803,10 @@ class XraySecurityAuditServer {
             ],
         };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "security-audit.server",
-            server: this.server,
-        });
-    }
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XraySecurityAuditServer();
-    server.run().catch(() => { });
+    server.run("security-audit").catch((err) => { frameworkLogger.log("security-audit", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 export { XraySecurityAuditServer };

package/dist/mcps/knowledge-skills/seo-consultant.server.d.ts

@@ -5,10 +5,9 @@
  * Provides schema markup, robots.txt, Core Web Vitals, AI search optimization,
  * sitemap generation, and deep technical SEO audits.
  */
-declare class SEOSpecialistServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class SEOSpecialistServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private auditTechnicalSEO;
     private generateSchemaMarkup;
     private generateMicrodata;
@@ -21,6 +20,5 @@ declare class SEOSpecialistServer {
     private generateSitemap;
     private optimizeRobotsTxt;
     private validateRobotsTxt;
-    run(): Promise<void>;
 }
 export { SEOSpecialistServer };

package/dist/mcps/knowledge-skills/seo-consultant.server.js

@@ -5,213 +5,98 @@
  * Provides schema markup, robots.txt, Core Web Vitals, AI search optimization,
  * sitemap generation, and deep technical SEO audits.
  */
-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 { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class SEOSpecialistServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+class SEOSpecialistServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({ name: "seo-consultant", version: "2.0.1" }, { capabilities: { tools: {} } });
-        this.setupToolHandlers();
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: "audit-technical-seo",
-                    description: "Perform deep technical SEO audit: schema markup, meta tags, heading structure, internal linking, performance, accessibility, mobile-friendliness",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            targetUrl: { type: "string", description: "Target URL to audit" },
-                            focusAreas: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "Areas to focus on (schema, performance, structure, links, accessibility)",
-                            },
-                        },
+        super("seo-consultant", "2.0.1");
+        this.tools = [
+            {
+                name: "audit-technical-seo",
+                description: "Perform deep technical SEO audit: schema markup, meta tags, heading structure, internal linking, performance, accessibility, mobile-friendliness",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        targetUrl: { type: "string", description: "Target URL to audit" },
+                        focusAreas: { type: "array", items: { type: "string" }, description: "Areas to focus on (schema, performance, structure, links, accessibility)" },
                     },
                 },
-                {
-                    name: "generate-schema-markup",
-                    description: "Generate JSON-LD schema markup for: Organization, Product, Article, FAQPage, BreadcrumbList, LocalBusiness, WebSite, HowTo, Recipe, Video, Audio, Course, Event, Person, Book, SoftwareApplication",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            schemaType: {
-                                type: "string",
-                                enum: [
-                                    "Organization",
-                                    "Product",
-                                    "Article",
-                                    "FAQPage",
-                                    "BreadcrumbList",
-                                    "LocalBusiness",
-                                    "WebSite",
-                                    "HowTo",
-                                    "Recipe",
-                                    "VideoObject",
-                                    "AudioObject",
-                                    "Course",
-                                    "Event",
-                                    "Person",
-                                    "Book",
-                                    "SoftwareApplication",
-                                ],
-                            },
-                            data: {
-                                type: "object",
-                                description: "Data to populate schema (varies by type)",
-                            },
-                            includeMicrodata: {
-                                type: "boolean",
-                                description: "Also generate HTML microdata format",
-                                default: false,
-                            },
-                        },
-                        required: ["schemaType", "data"],
+            },
+            {
+                name: "generate-schema-markup",
+                description: "Generate JSON-LD schema markup for: Organization, Product, Article, FAQPage, BreadcrumbList, LocalBusiness, WebSite, HowTo, Recipe, Video, Audio, Course, Event, Person, Book, SoftwareApplication",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        schemaType: { type: "string", enum: ["Organization", "Product", "Article", "FAQPage", "BreadcrumbList", "LocalBusiness", "WebSite", "HowTo", "Recipe", "VideoObject", "AudioObject", "Course", "Event", "Person", "Book", "SoftwareApplication"] },
+                        data: { type: "object", description: "Data to populate schema (varies by type)" },
+                        includeMicrodata: { type: "boolean", description: "Also generate HTML microdata format", default: false },
                     },
+                    required: ["schemaType", "data"],
                 },
-                {
-                    name: "optimize-core-web-vitals",
-                    description: "Analyze and provide optimization recommendations for LCP (Largest Contentful Paint), INP (Interaction to Next Paint), CLS (Cumulative Layout Shift)",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            url: { type: "string", description: "URL to analyze" },
-                            pageType: {
-                                type: "string",
-                                enum: ["homepage", "article", "product", "category", "landing"],
-                                description: "Type of page for context-specific recommendations",
-                            },
-                            currentMetrics: {
-                                type: "object",
-                                description: "Current Core Web Vitals values if known",
-                                properties: {
-                                    LCP: { type: "number" },
-                                    INP: { type: "number" },
-                                    CLS: { type: "number" },
-                                },
-                            },
-                        },
-                        required: ["url"],
+            },
+            {
+                name: "optimize-core-web-vitals",
+                description: "Analyze and provide optimization recommendations for LCP (Largest Contentful Paint), INP (Interaction to Next Paint), CLS (Cumulative Layout Shift)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        url: { type: "string", description: "URL to analyze" },
+                        pageType: { type: "string", enum: ["homepage", "article", "product", "category", "landing"], description: "Type of page for context-specific recommendations" },
+                        currentMetrics: { type: "object", description: "Current Core Web Vitals values if known", properties: { LCP: { type: "number" }, INP: { type: "number" }, CLS: { type: "number" } } },
                     },
+                    required: ["url"],
                 },
-                {
-                    name: "analyze-ai-search",
-                    description: "Optimize content for AI search engines (ChatGPT, Perplexity, Grok, Gemini, Claude). Analyze E-E-A-T signals, structure content for citation",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            content: { type: "string", description: "Content to optimize" },
-                            targetAI: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "Target AI engines (chatgpt, perplexity, grok, gemini, claude)",
-                            },
-                            pageContext: {
-                                type: "string",
-                                description: "Page context (documentation, blog, product, api)",
-                            },
-                        },
-                        required: ["content"],
+            },
+            {
+                name: "analyze-ai-search",
+                description: "Optimize content for AI search engines (ChatGPT, Perplexity, Grok, Gemini, Claude). Analyze E-E-A-T signals, structure content for citation",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string", description: "Content to optimize" },
+                        targetAI: { type: "array", items: { type: "string" }, description: "Target AI engines (chatgpt, perplexity, grok, gemini, claude)" },
+                        pageContext: { type: "string", description: "Page context (documentation, blog, product, api)" },
                     },
+                    required: ["content"],
                 },
-                {
-                    name: "generate-sitemap",
-                    description: "Generate XML sitemap for SEO with proper structure, priorities, and changefreq",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            baseUrl: { type: "string", description: "Base URL for sitemap" },
-                            pages: {
-                                type: "array",
-                                items: {
-                                    type: "object",
-                                    properties: {
-                                        path: { type: "string" },
-                                        lastmod: { type: "string" },
-                                        changefreq: {
-                                            type: "string",
-                                            enum: [
-                                                "always",
-                                                "hourly",
-                                                "daily",
-                                                "weekly",
-                                                "monthly",
-                                                "yearly",
-                                                "never",
-                                            ],
-                                        },
-                                        priority: { type: "number", minimum: 0, maximum: 1 },
-                                    },
-                                },
-                            },
-                            includeImages: { type: "boolean", default: false },
-                            includeVideos: { type: "boolean", default: false },
-                        },
-                        required: ["baseUrl", "pages"],
+            },
+            {
+                name: "generate-sitemap",
+                description: "Generate XML sitemap for SEO with proper structure, priorities, and changefreq",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        baseUrl: { type: "string", description: "Base URL for sitemap" },
+                        pages: { type: "array", items: { type: "object", properties: { path: { type: "string" }, lastmod: { type: "string" }, changefreq: { type: "string", enum: ["always", "hourly", "daily", "weekly", "monthly", "yearly", "never"] }, priority: { type: "number", minimum: 0, maximum: 1 } } } },
+                        includeImages: { type: "boolean", default: false },
+                        includeVideos: { type: "boolean", default: false },
                     },
+                    required: ["baseUrl", "pages"],
                 },
-                {
-                    name: "optimize-robots-txt",
-                    description: "Optimize robots.txt for SEO best practices, AI crawler optimization, and proper directive structure",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            baseUrl: { type: "string", description: "Site base URL" },
-                            options: {
-                                type: "object",
-                                properties: {
-                                    allowAI: { type: "boolean", description: "Allow AI crawlers", default: true },
-                                    allowSearchBots: {
-                                        type: "boolean",
-                                        description: "Allow standard search bots",
-                                        default: true,
-                                    },
-                                    blockPaths: {
-                                        type: "array",
-                                        items: { type: "string" },
-                                        description: "Paths to disallow",
-                                    },
-                                    crawlDelay: { type: "number", description: "Crawl delay in seconds" },
-                                    generateSitemapDirective: { type: "boolean", default: true },
-                                },
-                            },
-                        },
-                        required: ["baseUrl"],
+            },
+            {
+                name: "optimize-robots-txt",
+                description: "Optimize robots.txt for SEO best practices, AI crawler optimization, and proper directive structure",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        baseUrl: { type: "string", description: "Site base URL" },
+                        options: { type: "object", properties: { allowAI: { type: "boolean", description: "Allow AI crawlers", default: true }, allowSearchBots: { type: "boolean", description: "Allow standard search bots", default: true }, blockPaths: { type: "array", items: { type: "string" }, description: "Paths to disallow" }, crawlDelay: { type: "number", description: "Crawl delay in seconds" }, generateSitemapDirective: { type: "boolean", default: true } } },
                     },
+                    required: ["baseUrl"],
                 },
-            ],
-        }));
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args = {} } = request.params;
-            try {
-                switch (name) {
-                    case "audit-technical-seo":
-                        return this.auditTechnicalSEO(args);
-                    case "generate-schema-markup":
-                        return this.generateSchemaMarkup(args);
-                    case "optimize-core-web-vitals":
-                        return this.optimizeCoreWebVitals(args);
-                    case "analyze-ai-search":
-                        return this.analyzeAISearch(args);
-                    case "generate-sitemap":
-                        return this.generateSitemap(args);
-                    case "optimize-robots-txt":
-                        return this.optimizeRobotsTxt(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: `Error: ${error}` }],
-                    isError: true,
-                };
-            }
-        });
+            },
+        ];
+        this.handlers = {
+            "audit-technical-seo": async (args) => this.auditTechnicalSEO(args),
+            "generate-schema-markup": async (args) => this.generateSchemaMarkup(args),
+            "optimize-core-web-vitals": async (args) => this.optimizeCoreWebVitals(args),
+            "analyze-ai-search": async (args) => this.analyzeAISearch(args),
+            "generate-sitemap": async (args) => this.generateSitemap(args),
+            "optimize-robots-txt": async (args) => this.optimizeRobotsTxt(args),
+        };
+        this.setupToolHandlers();
     }
     auditTechnicalSEO(args) {
         const targetUrl = args.targetUrl || "https://example.com";
@@ -921,17 +806,9 @@ Sitemap: ${baseUrl}/sitemap.xml`;
         }
         return issues.join("\n");
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        createGracefulShutdown({
-            serverName: "seo-consultant.server",
-            server: this.server,
-        });
-    }
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new SEOSpecialistServer();
-    server.run().catch(() => { });
+    server.run("seo-consultant.server").catch((err) => { frameworkLogger.log("seo-consultant", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 export { SEOSpecialistServer };

package/dist/mcps/knowledge-skills/session-management.server.d.ts

@@ -4,10 +4,9 @@
  * Tools for managing user sessions and persistent state.
  * Provides session lifecycle management, state persistence, and cleanup utilities.
  */
-declare class SessionManagementServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class SessionManagementServer extends XrayKnowledgeSkillBase {
     private sessions;
-    private tools;
     constructor();
     private generateSessionId;
     private isExpired;
@@ -18,6 +17,5 @@ declare class SessionManagementServer {
     private handleListSessions;
     private handleSessionExists;
     private handleCleanupExpiredSessions;
-    run(): Promise<void>;
 }
 export default SessionManagementServer;