0xray 3.1.0 → 3.2.0

package/src/mcps/knowledge-skills/skill-invocation.server.ts

@@ -1,18 +1,16 @@
-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";
+import { skillInstallCommand, skillRegistryCommand } from "../../cli/commands/skill-install.js";
 
 interface ListSkillsArgs {
   category?: "all" | "core" | "registry" | "knowledge";
@@ -84,335 +82,55 @@ interface StorytellerArgs {
   framework?: "three_act_structure" | "hero_journey" | "spiral";
 }
 
-class SkillInvocationServer {
-  private server: Server;
+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 as ListSkillsArgs),
+      "invoke-skill": async (args) => this.handleInvokeSkill(args as InvokeSkillArgs),
+      "skill-code-review": async (args) => this.handleSkillCodeReview(args as CodeReviewArgs),
+      "skill-security-audit": async (args) => this.handleSkillSecurityAudit(args as SecurityAuditArgs),
+      "skill-performance-optimization": async (args) => this.handleSkillPerformanceOptimization(args as PerformanceOptimizationArgs),
+      "skill-testing-strategy": async (args) => this.handleSkillTestingStrategy(args as TestingStrategyArgs),
+      "skill-project-analysis": async (args) => this.handleSkillProjectAnalysis(args as ProjectAnalysisArgs),
+      "skill-database-design": async (args) => this.handleSkillDatabaseDesign(args as DatabaseDesignArgs),
+      "skill-devops-deployment": async (args) => this.handleSkillDevopsDeployment(args as DevopsDeploymentArgs),
+      "skill-api-design": async (args) => this.handleSkillApiDesign(args as ApiDesignArgs),
+      "skill-ui-ux-design": async (args) => this.handleSkillUiUxDesign(args as UiUxDesignArgs),
+      "skill-documentation-generation": async (args) => this.handleSkillDocumentationGeneration(args as DocumentationGenerationArgs),
+      "skill-storyteller": async (args) => this.handleSkillStoryteller(args as StorytellerArgs),
+      "install-skill": async (args) => this.handleInstallSkill(args as { source: string; path?: string; force?: boolean }),
+      "skill-registry-list": async () => this.handleSkillRegistryList(),
+      "skill-registry-add": async (args) => this.handleSkillRegistryAdd(args as { name: string; url: string; desc?: string; license?: string }),
+      "skill-registry-remove": async (args) => this.handleSkillRegistryRemove(args as { name: string }),
+    };
 
     this.setupToolHandlers();
   }
 
-  private 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 as unknown as ListSkillsArgs);
-          case "invoke-skill":
-            return await this.handleInvokeSkill(args as unknown as InvokeSkillArgs);
-          case "skill-code-review":
-            return await this.handleSkillCodeReview(args as unknown as CodeReviewArgs);
-          case "skill-security-audit":
-            return await this.handleSkillSecurityAudit(args as unknown as SecurityAuditArgs);
-          case "skill-performance-optimization":
-            return await this.handleSkillPerformanceOptimization(args as unknown as PerformanceOptimizationArgs);
-          case "skill-testing-strategy":
-            return await this.handleSkillTestingStrategy(args as unknown as TestingStrategyArgs);
-          case "skill-project-analysis":
-            return await this.handleSkillProjectAnalysis(args as unknown as ProjectAnalysisArgs);
-          case "skill-database-design":
-            return await this.handleSkillDatabaseDesign(args as unknown as DatabaseDesignArgs);
-          case "skill-devops-deployment":
-            return await this.handleSkillDevopsDeployment(args as unknown as DevopsDeploymentArgs);
-          case "skill-api-design":
-            return await this.handleSkillApiDesign(args as unknown as ApiDesignArgs);
-          case "skill-ui-ux-design":
-            return await this.handleSkillUiUxDesign(args as unknown as UiUxDesignArgs);
-          case "skill-documentation-generation":
-            return await this.handleSkillDocumentationGeneration(args as unknown as DocumentationGenerationArgs);
-          case "skill-storyteller":
-            return await this.handleSkillStoryteller(args as unknown as StorytellerArgs);
-          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
 
   private skillMetrics: Map<string, { success: number; failure: number; avgDuration: number }> = new Map();
 
@@ -824,63 +542,54 @@ class SkillInvocationServer {
     };
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-
-    let parentCheckTimer: ReturnType<typeof setTimeout> | null = null;
-
-    const cleanup = async (signal: string) => {
-      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"));
+  private async captureConsole(fn: () => Promise<void>): Promise<string> {
+    const chunks: string[] = [];
+    const origLog = console.log;
+    console.log = (...args: unknown[]) => chunks.push(args.map(String).join(" "));
+    try {
+      await fn();
+    } finally {
+      console.log = origLog;
+    }
+    return chunks.join("\n");
+  }
 
-    const checkParent = () => {
-      try {
-        process.kill(process.ppid, 0);
-        parentCheckTimer = setTimeout(checkParent, 1000);
-      } catch (error) {
-        parentCheckTimer = null;
-        cleanup("parent-process-death");
-      }
-    };
+  private async handleInstallSkill(args: { source: string; path?: string; force?: boolean }) {
+    const opts: { path?: string; force?: boolean } = {};
+    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." }] };
+  }
 
-    parentCheckTimer = setTimeout(checkParent, 2000);
+  private async handleSkillRegistryList() {
+    const output = await this.captureConsole(() =>
+      skillRegistryCommand("list")
+    );
+    return { content: [{ type: "text", text: output || "No registry sources configured." }] };
+  }
 
-    process.on("uncaughtException", (error) => {
-      frameworkLogger.log("mcps/skill-invocation", "uncaughtException", "error", { message: `Uncaught Exception: ${String(error)}` });
-      cleanup("uncaughtException");
-    });
+  private async handleSkillRegistryAdd(args: { name: string; url: string; desc?: string; license?: string }) {
+    const registryArgs: Record<string, string> = { 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." }] };
+  }
 
-    process.on("unhandledRejection", (reason) => {
-      frameworkLogger.log("mcps/skill-invocation", "unhandledRejection", "error", { message: `Unhandled Rejection: ${String(reason)}` });
-      cleanup("unhandledRejection");
-    });
+  private async handleSkillRegistryRemove(args: { name: string }) {
+    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).
    */
@@ -917,7 +626,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/src/mcps/knowledge-skills/strategist.server.ts

@@ -5,15 +5,10 @@
  * 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";
+import { XrayKnowledgeSkillBase, type ToolDefinition } from "../shared/knowledge-skill-base.js";
 
 interface Tool {
   name: string;
@@ -37,9 +32,8 @@ interface ArchitectureReviewArgs {
   requirements?: string[];
 }
 
-class StrategistServer {
-  private server: Server;
-  private tools: Tool[] = [
+class StrategistServer extends XrayKnowledgeSkillBase {
+  protected tools: ToolDefinition[] = [
     {
       name: "strategic_guidance",
       description:
@@ -108,58 +102,18 @@ 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 as StrategicGuidanceArgs),
+      risk_assessment: async (args) => this.handleRiskAssessment(args as RiskAssessmentArgs),
+      architecture_review: async (args) => this.handleArchitectureReview(args as ArchitectureReviewArgs),
+    };
 
     this.setupToolHandlers();
   }
 
-  private 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 as unknown as StrategicGuidanceArgs);
-          case "risk_assessment":
-            return await this.handleRiskAssessment(args as unknown as RiskAssessmentArgs);
-          case "architecture_review":
-            return await this.handleArchitectureReview(args as unknown as ArchitectureReviewArgs);
-          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
 
   private async handleStrategicGuidance(args: StrategicGuidanceArgs) {
     const { context, options = [], criteria = [] } = args;
@@ -251,17 +205,13 @@ class StrategistServer {
     };
   }
 
-  async start() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    await frameworkLogger.log("mcp-strategist", "server-started", "success");
-  }
+  // run() removed — handled by XrayKnowledgeSkillBase
 }
 
-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 };