0xray 3.1.0 → 3.2.0

package/src/mcps/knowledge-skills/seo-consultant.server.ts

@@ -6,13 +6,8 @@
  * 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";
+import * as fs from "fs";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 
 interface SEOIssue {
   priority: "critical" | "high" | "medium" | "low";
@@ -64,223 +59,33 @@ interface RobotsConfig {
 
 type ToolInputSchema = Record<string, unknown>;
 
-class SEOSpecialistServer {
-  private server: Server;
+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 as ToolInputSchema),
+      "generate-schema-markup": async (args) => this.generateSchemaMarkup(args as ToolInputSchema),
+      "optimize-core-web-vitals": async (args) => this.optimizeCoreWebVitals(args as ToolInputSchema),
+      "analyze-ai-search": async (args) => this.analyzeAISearch(args as ToolInputSchema),
+      "generate-sitemap": async (args) => this.generateSitemap(args as ToolInputSchema),
+      "optimize-robots-txt": async (args) => this.optimizeRobotsTxt(args as ToolInputSchema),
+    };
 
     this.setupToolHandlers();
   }
 
-  private 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
 
   private auditTechnicalSEO(args: ToolInputSchema): {
     content: { type: string; text: string }[];
@@ -1141,18 +946,10 @@ Sitemap: ${baseUrl}/sitemap.xml`;
     return issues.join("\n");
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-
-    createGracefulShutdown({
-      serverName: "seo-consultant.server",
-      server: this.server,
-    });
-  }
+  // run() removed — handled by XrayKnowledgeSkillBase
 }
 
-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/src/mcps/knowledge-skills/session-management.server.ts

@@ -5,13 +5,9 @@
  * 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";
+import { XrayKnowledgeSkillBase, type ToolDefinition } from "../shared/knowledge-skill-base.js";
 
 interface Tool {
   name: string;
@@ -28,10 +24,9 @@ interface SessionData {
   expiresAt: number | undefined;
 }
 
-class SessionManagementServer {
-  private server: Server;
+class SessionManagementServer extends XrayKnowledgeSkillBase {
   private sessions: Map<string, SessionData> = new Map();
-  private tools: Tool[] = [
+  protected tools: ToolDefinition[] = [
     {
       name: "create_session",
       description:
@@ -160,49 +155,19 @@ 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 as Record<string, unknown>),
+      get_session: async (args) => this.handleGetSession(args as Record<string, unknown>),
+      update_session: async (args) => this.handleUpdateSession(args as Record<string, unknown>),
+      delete_session: async (args) => this.handleDeleteSession(args as Record<string, unknown>),
+      list_sessions: async (args) => this.handleListSessions(args as Record<string, unknown>),
+      session_exists: async (args) => this.handleSessionExists(args as Record<string, unknown>),
+      cleanup_expired_sessions: async (args) => this.handleCleanupExpiredSessions(args as Record<string, unknown>),
+    };
+
+    this.setupToolHandlers();
   }
 
   private generateSessionId(): string {
@@ -512,63 +477,10 @@ class SessionManagementServer {
     };
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-
-    await frameworkLogger.log("mcp-session-management", "server-started", "success");
-
-    const cleanup = async (signal: string) => {
-      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");
-    });
-  }
+  // run() removed — handled by XrayKnowledgeSkillBase
 }
 
-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) }));
 }