0xray 3.1.0 → 3.2.0

package/dist/mcps/knowledge-skills/skill-invocation.server.js

@@ -1,322 +1,56 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
-import * as path from "path";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import * as fs from "fs";
 import { fileURLToPath } from "url";
 import { randomUUID } from "crypto";
 import { mcpClientManager } from "../mcp-client.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
-class SkillInvocationServer {
-    server;
+import { skillInstallCommand, skillRegistryCommand } from "../../cli/commands/skill-install.js";
+class SkillInvocationServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "xray/skill-invocation", version: "1.22.67",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("skill-invocation", "3.1.0");
+        this.tools = [
+            { name: "list-skills", description: "List all available skills with descriptions", inputSchema: { type: "object", properties: { category: { type: "string", enum: ["all", "core", "registry", "knowledge"], description: "Filter by category" } } } },
+            { name: "invoke-skill", description: "Generic skill invocation tool for calling any MCP skill server", inputSchema: { type: "object", properties: { skillName: { type: "string", description: "Name of the skill to invoke (use list-skills to see available)" }, toolName: { type: "string", description: "Name of the tool within the skill to execute" }, args: { type: "object", description: "Arguments to pass to the skill tool" } }, required: ["skillName", "toolName"] } },
+            { name: "skill-code-review", description: "Invoke code review skill for comprehensive code analysis", inputSchema: { type: "object", properties: { code: { type: "string", description: "Code to analyze" }, language: { type: "string", description: "Programming language" }, context: { type: "object", description: "Additional context" } }, required: ["code"] } },
+            { name: "skill-security-audit", description: "Invoke security audit skill for vulnerability scanning", inputSchema: { type: "object", properties: { files: { type: "array", items: { type: "string" }, description: "Files to audit" }, severity: { type: "string", enum: ["low", "medium", "high", "critical"], description: "Minimum severity level" } }, required: ["files"] } },
+            { name: "skill-performance-optimization", description: "Invoke performance optimization skill for bottleneck analysis", inputSchema: { type: "object", properties: { code: { type: "string", description: "Code to analyze" }, language: { type: "string", description: "Programming language" }, metrics: { type: "array", items: { type: "string" }, description: "Performance metrics to analyze" } }, required: ["code"] } },
+            { name: "skill-testing-strategy", description: "Invoke testing strategy skill for test planning", inputSchema: { type: "object", properties: { code: { type: "string", description: "Code to analyze for testing" }, existingTests: { type: "array", items: { type: "string" }, description: "Existing test files" }, requirements: { type: "object", description: "Testing requirements and constraints" } }, required: ["code"] } },
+            { name: "skill-project-analysis", description: "Invoke project analysis skill for codebase insights", inputSchema: { type: "object", properties: { scope: { type: "string", enum: ["full", "directory", "file"], description: "Analysis scope" }, analysis: { type: "array", items: { type: "string" }, description: "Types of analysis to perform" } } } },
+            { name: "skill-database-design", description: "Invoke database design skill for schema design and query optimization", inputSchema: { type: "object", properties: { schema: { type: "string", description: "Database schema or entities" }, databaseType: { type: "string", enum: ["postgresql", "mysql", "mongodb", "dynamodb"], description: "Target database type" } }, required: ["schema"] } },
+            { name: "skill-devops-deployment", description: "Invoke DevOps deployment skill for CI/CD and infrastructure", inputSchema: { type: "object", properties: { projectType: { type: "string", description: "Type of project" }, cloudProvider: { type: "string", enum: ["aws", "gcp", "azure"], description: "Target cloud provider" } }, required: ["projectType"] } },
+            { name: "skill-api-design", description: "Invoke API design skill for REST/GraphQL endpoints", inputSchema: { type: "object", properties: { resources: { type: "array", items: { type: "string" }, description: "API resources" }, style: { type: "string", enum: ["rest", "graphql"], description: "API style" } }, required: ["resources"] } },
+            { name: "skill-ui-ux-design", description: "Invoke UI/UX design skill for component design", inputSchema: { type: "object", properties: { component: { type: "string", description: "Component to design" }, framework: { type: "string", enum: ["react", "vue", "angular", "svelte"], description: "Target framework" } }, required: ["component"] } },
+            { name: "skill-documentation-generation", description: "Invoke documentation skill for API docs and README", inputSchema: { type: "object", properties: { type: { type: "string", enum: ["api", "readme", "guide"], description: "Documentation type" }, code: { type: "string", description: "Code to document" } }, required: ["type"] } },
+            { name: "skill-storyteller", description: "Invoke storyteller skill for writing reflections, sagas, and journeys", inputSchema: { type: "object", properties: { storyType: { type: "string", enum: ["reflection", "saga", "journey", "narrative"], description: "Type of story to write" }, title: { type: "string", description: "Title for the story" }, context: { type: "object", description: "Context including commits, changes, metadata" }, framework: { type: "string", enum: ["three_act_structure", "hero_journey", "spiral"], description: "Storytelling framework to use" } }, required: ["storyType"] } },
+            { name: "install-skill", description: "Install skills from the registry or any git repo", inputSchema: { type: "object", properties: { source: { type: "string", description: "Source name or git URL to install skills from" }, path: { type: "string", description: "Subdirectory in repo containing skills" }, force: { type: "boolean", description: "Reinstall even if already installed" } }, required: ["source"] } },
+            { name: "skill-registry-list", description: "List all available skill registry sources", inputSchema: { type: "object", properties: {} } },
+            { name: "skill-registry-add", description: "Add a new source to the skills registry", inputSchema: { type: "object", properties: { name: { type: "string", description: "Unique source name" }, url: { type: "string", description: "Repository URL" }, desc: { type: "string", description: "Short description" }, license: { type: "string", description: "License type" } }, required: ["name", "url"] } },
+            { name: "skill-registry-remove", description: "Remove a source from the skills registry", inputSchema: { type: "object", properties: { name: { type: "string", description: "Source name to remove" } }, required: ["name"] } },
+        ];
+        this.handlers = {
+            "list-skills": async (args) => this.handleListSkills(args),
+            "invoke-skill": async (args) => this.handleInvokeSkill(args),
+            "skill-code-review": async (args) => this.handleSkillCodeReview(args),
+            "skill-security-audit": async (args) => this.handleSkillSecurityAudit(args),
+            "skill-performance-optimization": async (args) => this.handleSkillPerformanceOptimization(args),
+            "skill-testing-strategy": async (args) => this.handleSkillTestingStrategy(args),
+            "skill-project-analysis": async (args) => this.handleSkillProjectAnalysis(args),
+            "skill-database-design": async (args) => this.handleSkillDatabaseDesign(args),
+            "skill-devops-deployment": async (args) => this.handleSkillDevopsDeployment(args),
+            "skill-api-design": async (args) => this.handleSkillApiDesign(args),
+            "skill-ui-ux-design": async (args) => this.handleSkillUiUxDesign(args),
+            "skill-documentation-generation": async (args) => this.handleSkillDocumentationGeneration(args),
+            "skill-storyteller": async (args) => this.handleSkillStoryteller(args),
+            "install-skill": async (args) => this.handleInstallSkill(args),
+            "skill-registry-list": async () => this.handleSkillRegistryList(),
+            "skill-registry-add": async (args) => this.handleSkillRegistryAdd(args),
+            "skill-registry-remove": async (args) => this.handleSkillRegistryRemove(args),
+        };
         this.setupToolHandlers();
     }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "list-skills",
-                        description: "List all available skills with descriptions",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                category: {
-                                    type: "string",
-                                    enum: ["all", "core", "registry", "knowledge"],
-                                    description: "Filter by category",
-                                },
-                            },
-                        },
-                    },
-                    {
-                        name: "invoke-skill",
-                        description: "Generic skill invocation tool for calling any MCP skill server",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                skillName: {
-                                    type: "string",
-                                    description: "Name of the skill to invoke (use list-skills to see available)",
-                                },
-                                toolName: {
-                                    type: "string",
-                                    description: "Name of the tool within the skill to execute",
-                                },
-                                args: {
-                                    type: "object",
-                                    description: "Arguments to pass to the skill tool",
-                                },
-                            },
-                            required: ["skillName", "toolName"],
-                        },
-                    },
-                    {
-                        name: "skill-code-review",
-                        description: "Invoke code review skill for comprehensive code analysis",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                code: { type: "string", description: "Code to analyze" },
-                                language: {
-                                    type: "string",
-                                    description: "Programming language",
-                                },
-                                context: { type: "object", description: "Additional context" },
-                            },
-                            required: ["code"],
-                        },
-                    },
-                    {
-                        name: "skill-security-audit",
-                        description: "Invoke security audit skill for vulnerability scanning",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                files: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Files to audit",
-                                },
-                                severity: {
-                                    type: "string",
-                                    enum: ["low", "medium", "high", "critical"],
-                                    description: "Minimum severity level",
-                                },
-                            },
-                            required: ["files"],
-                        },
-                    },
-                    {
-                        name: "skill-performance-optimization",
-                        description: "Invoke performance optimization skill for bottleneck analysis",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                code: { type: "string", description: "Code to analyze" },
-                                language: {
-                                    type: "string",
-                                    description: "Programming language",
-                                },
-                                metrics: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Performance metrics to analyze",
-                                },
-                            },
-                            required: ["code"],
-                        },
-                    },
-                    {
-                        name: "skill-testing-strategy",
-                        description: "Invoke testing strategy skill for test planning",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                code: {
-                                    type: "string",
-                                    description: "Code to analyze for testing",
-                                },
-                                existingTests: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Existing test files",
-                                },
-                                requirements: {
-                                    type: "object",
-                                    description: "Testing requirements and constraints",
-                                },
-                            },
-                            required: ["code"],
-                        },
-                    },
-                    {
-                        name: "skill-project-analysis",
-                        description: "Invoke project analysis skill for codebase insights",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                scope: {
-                                    type: "string",
-                                    enum: ["full", "directory", "file"],
-                                    description: "Analysis scope",
-                                },
-                                analysis: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Types of analysis to perform",
-                                },
-                            },
-                        },
-                    },
-                    {
-                        name: "skill-database-design",
-                        description: "Invoke database design skill for schema design and query optimization",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                schema: {
-                                    type: "string",
-                                    description: "Database schema or entities",
-                                },
-                                databaseType: {
-                                    type: "string",
-                                    enum: ["postgresql", "mysql", "mongodb", "dynamodb"],
-                                    description: "Target database type",
-                                },
-                            },
-                            required: ["schema"],
-                        },
-                    },
-                    {
-                        name: "skill-devops-deployment",
-                        description: "Invoke DevOps deployment skill for CI/CD and infrastructure",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectType: { type: "string", description: "Type of project" },
-                                cloudProvider: {
-                                    type: "string",
-                                    enum: ["aws", "gcp", "azure"],
-                                    description: "Target cloud provider",
-                                },
-                            },
-                            required: ["projectType"],
-                        },
-                    },
-                    {
-                        name: "skill-api-design",
-                        description: "Invoke API design skill for REST/GraphQL endpoints",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                resources: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "API resources",
-                                },
-                                style: {
-                                    type: "string",
-                                    enum: ["rest", "graphql"],
-                                    description: "API style",
-                                },
-                            },
-                            required: ["resources"],
-                        },
-                    },
-                    {
-                        name: "skill-ui-ux-design",
-                        description: "Invoke UI/UX design skill for component design",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                component: {
-                                    type: "string",
-                                    description: "Component to design",
-                                },
-                                framework: {
-                                    type: "string",
-                                    enum: ["react", "vue", "angular", "svelte"],
-                                    description: "Target framework",
-                                },
-                            },
-                            required: ["component"],
-                        },
-                    },
-                    {
-                        name: "skill-documentation-generation",
-                        description: "Invoke documentation skill for API docs and README",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                type: {
-                                    type: "string",
-                                    enum: ["api", "readme", "guide"],
-                                    description: "Documentation type",
-                                },
-                                code: { type: "string", description: "Code to document" },
-                            },
-                            required: ["type"],
-                        },
-                    },
-                    {
-                        name: "skill-storyteller",
-                        description: "Invoke storyteller skill for writing reflections, sagas, and journeys",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                storyType: {
-                                    type: "string",
-                                    enum: ["reflection", "saga", "journey", "narrative"],
-                                    description: "Type of story to write",
-                                },
-                                title: { type: "string", description: "Title for the story" },
-                                context: {
-                                    type: "object",
-                                    description: "Context including commits, changes, metadata",
-                                },
-                                framework: {
-                                    type: "string",
-                                    enum: ["three_act_structure", "hero_journey", "spiral"],
-                                    description: "Storytelling framework to use",
-                                },
-                            },
-                            required: ["storyType"],
-                        },
-                    },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case "list-skills":
-                        return await this.handleListSkills(args);
-                    case "invoke-skill":
-                        return await this.handleInvokeSkill(args);
-                    case "skill-code-review":
-                        return await this.handleSkillCodeReview(args);
-                    case "skill-security-audit":
-                        return await this.handleSkillSecurityAudit(args);
-                    case "skill-performance-optimization":
-                        return await this.handleSkillPerformanceOptimization(args);
-                    case "skill-testing-strategy":
-                        return await this.handleSkillTestingStrategy(args);
-                    case "skill-project-analysis":
-                        return await this.handleSkillProjectAnalysis(args);
-                    case "skill-database-design":
-                        return await this.handleSkillDatabaseDesign(args);
-                    case "skill-devops-deployment":
-                        return await this.handleSkillDevopsDeployment(args);
-                    case "skill-api-design":
-                        return await this.handleSkillApiDesign(args);
-                    case "skill-ui-ux-design":
-                        return await this.handleSkillUiUxDesign(args);
-                    case "skill-documentation-generation":
-                        return await this.handleSkillDocumentationGeneration(args);
-                    case "skill-storyteller":
-                        return await this.handleSkillStoryteller(args);
-                    default:
-                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        });
-    }
+    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
     skillMetrics = new Map();
     /**
      * Record skill invocation outcome for adaptive learning
@@ -626,55 +360,45 @@ class SkillInvocationServer {
             ],
         };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        let parentCheckTimer = null;
-        const cleanup = async (signal) => {
-            if (parentCheckTimer !== null) {
-                clearTimeout(parentCheckTimer);
-                parentCheckTimer = null;
-            }
-            const timeout = setTimeout(() => {
-                frameworkLogger.log("mcps/skill-invocation", "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);
-                process.exit(0);
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                frameworkLogger.log("mcps/skill-invocation", "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);
-                parentCheckTimer = setTimeout(checkParent, 1000);
-            }
-            catch (error) {
-                parentCheckTimer = null;
-                cleanup("parent-process-death");
-            }
-        };
-        parentCheckTimer = setTimeout(checkParent, 2000);
-        process.on("uncaughtException", (error) => {
-            frameworkLogger.log("mcps/skill-invocation", "uncaughtException", "error", { message: `Uncaught Exception: ${String(error)}` });
-            cleanup("uncaughtException");
-        });
-        process.on("unhandledRejection", (reason) => {
-            frameworkLogger.log("mcps/skill-invocation", "unhandledRejection", "error", { message: `Unhandled Rejection: ${String(reason)}` });
-            cleanup("unhandledRejection");
-        });
+    async captureConsole(fn) {
+        const chunks = [];
+        const origLog = console.log;
+        console.log = (...args) => chunks.push(args.map(String).join(" "));
+        try {
+            await fn();
+        }
+        finally {
+            console.log = origLog;
+        }
+        return chunks.join("\n");
+    }
+    async handleInstallSkill(args) {
+        const opts = {};
+        if (args.path !== undefined)
+            opts.path = args.path;
+        if (args.force !== undefined)
+            opts.force = args.force;
+        const output = await this.captureConsole(() => skillInstallCommand(args.source, opts));
+        return { content: [{ type: "text", text: output || "Skill installation completed." }] };
+    }
+    async handleSkillRegistryList() {
+        const output = await this.captureConsole(() => skillRegistryCommand("list"));
+        return { content: [{ type: "text", text: output || "No registry sources configured." }] };
+    }
+    async handleSkillRegistryAdd(args) {
+        const registryArgs = { name: args.name, url: args.url };
+        if (args.desc !== undefined)
+            registryArgs.desc = args.desc;
+        if (args.license !== undefined)
+            registryArgs.license = args.license;
+        const output = await this.captureConsole(() => skillRegistryCommand("add", registryArgs));
+        return { content: [{ type: "text", text: output || "Source added." }] };
+    }
+    async handleSkillRegistryRemove(args) {
+        const output = await this.captureConsole(() => skillRegistryCommand("remove", { name: args.name }));
+        return { content: [{ type: "text", text: output || "Source removed." }] };
     }
+    // run() removed — handled by XrayKnowledgeSkillBase
     /**
      * Run as HTTP server using Streamable HTTP transport (for Grok CLI compatibility).
      */
@@ -706,7 +430,7 @@ class SkillInvocationServer {
     }
 }
 // Start the server if this file is run directly
-const entryPoint = path.resolve(process.argv[1] ?? "");
+const entryPoint = fs.realpathSync(process.argv[1] ?? "");
 if (entryPoint && fileURLToPath(import.meta.url) === entryPoint) {
     // If --port or MCP_PORT is set, use HTTP transport (for Grok CLI compatibility)
     const cliPort = process.argv.find((a) => a.startsWith("--port="))?.split("=")[1];

package/dist/mcps/knowledge-skills/strategist.server.js

@@ -4,14 +4,11 @@
  * Strategic guidance and complex problem-solving for architectural decisions.
  * Provides strategic planning, risk assessment, and technical strategy tools.
  */
-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 path from "path";
+import * as fs from "fs";
 import { fileURLToPath } from "url";
 import { frameworkLogger } from "../../core/framework-logger.js";
-class StrategistServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+class StrategistServer extends XrayKnowledgeSkillBase {
     tools = [
         {
             name: "strategic_guidance",
@@ -77,52 +74,15 @@ class StrategistServer {
         },
     ];
     constructor() {
-        this.server = new Server({
-            name: "xray/strategist", version: "1.22.67",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("strategist", "3.1.0");
+        this.handlers = {
+            strategic_guidance: async (args) => this.handleStrategicGuidance(args),
+            risk_assessment: async (args) => this.handleRiskAssessment(args),
+            architecture_review: async (args) => this.handleArchitectureReview(args),
+        };
         this.setupToolHandlers();
     }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: this.tools.map((tool) => ({
-                    name: tool.name,
-                    description: tool.description,
-                    inputSchema: tool.inputSchema,
-                })),
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case "strategic_guidance":
-                        return await this.handleStrategicGuidance(args);
-                    case "risk_assessment":
-                        return await this.handleRiskAssessment(args);
-                    case "architecture_review":
-                        return await this.handleArchitectureReview(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,
-                };
-            }
-        });
-    }
+    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
     async handleStrategicGuidance(args) {
         const { context, options = [], criteria = [] } = args;
         const analysis = [
@@ -203,15 +163,10 @@ class StrategistServer {
             content: [{ type: "text", text: analysis.join("\n") }],
         };
     }
-    async start() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        await frameworkLogger.log("mcp-strategist", "server-started", "success");
-    }
 }
-const entryPoint = path.resolve(process.argv[1] ?? "");
+const entryPoint = fs.realpathSync(process.argv[1] ?? "");
 if (entryPoint && fileURLToPath(import.meta.url) === entryPoint) {
     const server = new StrategistServer();
-    server.start().catch((error) => frameworkLogger.log("mcps/strategist", "run", "error", { error: String(error) }));
+    server.run().catch((error) => frameworkLogger.log("mcps/strategist", "run", "error", { error: String(error) }));
 }
 export { StrategistServer };