0xray 3.0.12 → 3.1.0

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

@@ -5,107 +5,212 @@
  * Provides schema markup, robots.txt, Core Web Vitals, AI search optimization,
  * sitemap generation, and deep technical SEO audits.
  */
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { pluginRegistry } from "../../nucleus/plugin-registry.js";
-class SEOSpecialistServer extends XrayKnowledgeSkillBase {
+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;
     constructor() {
-        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)" },
+        this.server = new Server({ name: "seo-consultant", version: "1.22.67" }, { 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)",
+                            },
+                        },
                     },
                 },
-            },
-            {
-                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 },
+                {
+                    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"],
                     },
-                    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" } } },
+                {
+                    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"],
                     },
-                    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)" },
+                {
+                    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"],
                     },
-                    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 },
+                {
+                    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"],
                     },
-                    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 } } },
+                {
+                    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"],
                     },
-                    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();
-        pluginRegistry.registerToolPlugin({
-            name: "seo-consultant",
-            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;
+            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,
+                };
+            }
         });
     }
     auditTechnicalSEO(args) {
@@ -816,10 +921,17 @@ 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("seo-consultant.server").catch((err) => { frameworkLogger.log("seo-consultant", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
+    server.run().catch(() => { });
 }
 export { SEOSpecialistServer };
-//# sourceMappingURL=seo-consultant.server.js.map

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

@@ -4,66 +4,172 @@
  * Tools for managing user sessions and persistent state.
  * Provides session lifecycle management, state persistence, and cleanup utilities.
  */
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.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 { frameworkLogger } from "../../core/framework-logger.js";
-class SessionManagementServer extends XrayKnowledgeSkillBase {
+class SessionManagementServer {
+    server;
     sessions = new Map();
-    constructor() {
-        super("session-management", "2.0.1");
-        this.tools = [
-            {
-                name: "create_session",
-                description: "Create a new session with optional data and expiration",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        sessionId: { type: "string", description: "Optional custom session ID (generated if not provided)" },
-                        data: { type: "object", description: "Initial session data" },
-                        ttl: { type: "number", description: "Time to live in seconds (optional)" },
+    tools = [
+        {
+            name: "create_session",
+            description: "Create a new session with optional data and expiration",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Optional custom session ID (generated if not provided)",
+                    },
+                    data: {
+                        type: "object",
+                        description: "Initial session data",
+                    },
+                    ttl: {
+                        type: "number",
+                        description: "Time to live in seconds (optional)",
                     },
                 },
             },
-            {
-                name: "get_session",
-                description: "Retrieve session data by session ID",
-                inputSchema: { type: "object", properties: { sessionId: { type: "string", description: "Session ID to retrieve" } }, required: ["sessionId"] },
+        },
+        {
+            name: "get_session",
+            description: "Retrieve session data by session ID",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Session ID to retrieve",
+                    },
+                },
+                required: ["sessionId"],
             },
-            {
-                name: "update_session",
-                description: "Update session data",
-                inputSchema: { type: "object", properties: { sessionId: { type: "string", description: "Session ID to update" }, data: { type: "object", description: "Data to merge with existing session" }, extendTtl: { type: "number", description: "Extend TTL by this many seconds" } }, required: ["sessionId", "data"] },
+        },
+        {
+            name: "update_session",
+            description: "Update session data",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Session ID to update",
+                    },
+                    data: {
+                        type: "object",
+                        description: "Data to merge with existing session",
+                    },
+                    extendTtl: {
+                        type: "number",
+                        description: "Extend TTL by this many seconds",
+                    },
+                },
+                required: ["sessionId", "data"],
             },
-            {
-                name: "delete_session",
-                description: "Delete a session",
-                inputSchema: { type: "object", properties: { sessionId: { type: "string", description: "Session ID to delete" } }, required: ["sessionId"] },
+        },
+        {
+            name: "delete_session",
+            description: "Delete a session",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Session ID to delete",
+                    },
+                },
+                required: ["sessionId"],
             },
-            {
-                name: "list_sessions",
-                description: "List all active sessions",
-                inputSchema: { type: "object", properties: { includeExpired: { type: "boolean", default: false, description: "Include expired sessions in the list" }, limit: { type: "number", default: 50, description: "Maximum number of sessions to return" } } },
+        },
+        {
+            name: "list_sessions",
+            description: "List all active sessions",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    includeExpired: {
+                        type: "boolean",
+                        default: false,
+                        description: "Include expired sessions in the list",
+                    },
+                    limit: {
+                        type: "number",
+                        default: 50,
+                        description: "Maximum number of sessions to return",
+                    },
+                },
             },
-            {
-                name: "session_exists",
-                description: "Check if a session exists and is valid",
-                inputSchema: { type: "object", properties: { sessionId: { type: "string", description: "Session ID to check" } }, required: ["sessionId"] },
+        },
+        {
+            name: "session_exists",
+            description: "Check if a session exists and is valid",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Session ID to check",
+                    },
+                },
+                required: ["sessionId"],
             },
-            {
-                name: "cleanup_expired_sessions",
-                description: "Clean up all expired sessions",
-                inputSchema: { type: "object", properties: { dryRun: { type: "boolean", default: false, description: "If true, only return what would be deleted without deleting" } } },
+        },
+        {
+            name: "cleanup_expired_sessions",
+            description: "Clean up all expired sessions",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    dryRun: {
+                        type: "boolean",
+                        default: false,
+                        description: "If true, only return what would be deleted without deleting",
+                    },
+                },
             },
-        ];
-        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();
+        },
+    ];
+    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,
+                };
+            }
+        });
     }
     generateSessionId() {
         return `session_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
@@ -309,10 +415,56 @@ class SessionManagementServer extends XrayKnowledgeSkillBase {
             ],
         };
     }
+    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]}`) {
     const server = new SessionManagementServer();
-    server.run("session-management").catch((error) => frameworkLogger.log("mcps/session-management", "run", "error", { error: String(error) }));
+    server.run().catch((error) => frameworkLogger.log("mcps/session-management", "run", "error", { error: String(error) }));
 }
 export default SessionManagementServer;
-//# sourceMappingURL=session-management.server.js.map