0xray 3.1.0 → 3.2.0

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

@@ -5,214 +5,30 @@
  * 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 * as fs from "fs";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+class SEOSpecialistServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({ name: "seo-consultant", version: "1.22.67" }, { capabilities: { tools: {} } });
+        super("seo-consultant", "3.1.0");
+        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: "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: "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"] } },
+        ];
+        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();
     }
-    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)",
-                            },
-                        },
-                    },
-                },
-                {
-                    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: "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: "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,
-                };
-            }
-        });
-    }
+    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
     auditTechnicalSEO(args) {
         const targetUrl = args.targetUrl || "https://example.com";
         const focusAreas = args.focusAreas || [
@@ -921,16 +737,8 @@ 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]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new SEOSpecialistServer();
     server.run().catch(() => { });
 }

package/dist/mcps/knowledge-skills/session-management.server.js

@@ -4,12 +4,10 @@
  * Tools for managing user sessions and persistent state.
  * Provides session lifecycle management, state persistence, and cleanup utilities.
  */
-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 { frameworkLogger } from "../../core/framework-logger.js";
-class SessionManagementServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+class SessionManagementServer extends XrayKnowledgeSkillBase {
     sessions = new Map();
     tools = [
         {
@@ -132,44 +130,17 @@ class SessionManagementServer {
         },
     ];
     constructor() {
-        this.server = new Server({ name: "session-management", version: "1.22.67" }, { capabilities: { tools: {} } });
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: this.tools,
-        }));
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args = {} } = request.params;
-            try {
-                switch (name) {
-                    case "create_session":
-                        return this.handleCreateSession(args);
-                    case "get_session":
-                        return this.handleGetSession(args);
-                    case "update_session":
-                        return this.handleUpdateSession(args);
-                    case "delete_session":
-                        return this.handleDeleteSession(args);
-                    case "list_sessions":
-                        return this.handleListSessions(args);
-                    case "session_exists":
-                        return this.handleSessionExists(args);
-                    case "cleanup_expired_sessions":
-                        return this.handleCleanupExpiredSessions(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        });
+        super("session-management", "3.1.0");
+        this.handlers = {
+            create_session: async (args) => this.handleCreateSession(args),
+            get_session: async (args) => this.handleGetSession(args),
+            update_session: async (args) => this.handleUpdateSession(args),
+            delete_session: async (args) => this.handleDeleteSession(args),
+            list_sessions: async (args) => this.handleListSessions(args),
+            session_exists: async (args) => this.handleSessionExists(args),
+            cleanup_expired_sessions: async (args) => this.handleCleanupExpiredSessions(args),
+        };
+        this.setupToolHandlers();
     }
     generateSessionId() {
         return `session_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
@@ -415,55 +386,8 @@ class SessionManagementServer {
             ],
         };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        await frameworkLogger.log("mcp-session-management", "server-started", "success");
-        const cleanup = async (signal) => {
-            frameworkLogger.log("mcps/session-management", "shutdown", "info", { signal });
-            const timeout = setTimeout(() => {
-                frameworkLogger.log("mcps/session-management", "shutdown", "error", { message: "Graceful shutdown timeout, forcing exit..." });
-                process.exit(1);
-            }, 5000);
-            try {
-                if (this.server && typeof this.server.close === "function") {
-                    await this.server.close();
-                }
-                clearTimeout(timeout);
-                frameworkLogger.log("mcps/session-management", "shutdown", "success");
-                process.exit(0);
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                frameworkLogger.log("mcps/session-management", "shutdown", "error", { message: `Error during server shutdown: ${String(error)}` });
-                process.exit(1);
-            }
-        };
-        process.on("SIGINT", () => cleanup("SIGINT"));
-        process.on("SIGTERM", () => cleanup("SIGTERM"));
-        process.on("SIGHUP", () => cleanup("SIGHUP"));
-        const checkParent = () => {
-            try {
-                process.kill(process.ppid, 0);
-                setTimeout(checkParent, 1000);
-            }
-            catch {
-                frameworkLogger.log("mcps/session-management", "parent-death", "info");
-                cleanup("parent-process-death");
-            }
-        };
-        setTimeout(checkParent, 2000);
-        process.on("uncaughtException", (error) => {
-            frameworkLogger.log("mcps/session-management", "uncaughtException", "error", { error: String(error) });
-            cleanup("uncaughtException");
-        });
-        process.on("unhandledRejection", (reason, promise) => {
-            frameworkLogger.log("mcps/session-management", "unhandledRejection", "error", { error: String(reason) });
-            cleanup("unhandledRejection");
-        });
-    }
 }
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new SessionManagementServer();
     server.run().catch((error) => frameworkLogger.log("mcps/session-management", "run", "error", { error: String(error) }));
 }