0xray 2.1.1 → 2.1.3

package/dist/mcps/auto-format.server.js

@@ -3,104 +3,63 @@
  *
  * Automated code formatting hook with Prettier and framework-specific formatters
  */
-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 { execFileSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
-class XrayAutoFormatServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayAutoFormatServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "auto-format", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        frameworkLogger.log("mcps/auto-format", "initialize", "info");
-    }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "auto-format",
-                        description: "Automated code formatting hook with Prettier and framework-specific formatters",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                files: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific files to format (optional - formats all if empty)",
-                                },
-                                formatters: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: ["prettier", "eslint", "typescript", "all"],
-                                    },
-                                    default: ["all"],
-                                    description: "Formatters to apply",
-                                },
-                                checkOnly: {
-                                    type: "boolean",
-                                    default: false,
-                                    description: "Only check formatting without applying changes",
-                                },
-                            },
+        super("auto-format", "2.0.1");
+        this.tools = [
+            {
+                name: "auto-format",
+                description: "Automated code formatting hook with Prettier and framework-specific formatters",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific files to format (optional - formats all if empty)",
                         },
-                    },
-                    {
-                        name: "format-check",
-                        description: "Check if code is properly formatted without making changes",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                files: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Files to check formatting for",
-                                },
+                        formatters: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: ["prettier", "eslint", "typescript", "all"],
                             },
+                            default: ["all"],
+                            description: "Formatters to apply",
+                        },
+                        checkOnly: {
+                            type: "boolean",
+                            default: false,
+                            description: "Only check formatting without applying changes",
                         },
                     },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case "auto-format":
-                        return await this.handleAutoFormat(args);
-                    case "format-check":
-                        return await this.handleFormatCheck(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                frameworkLogger.log("mcps/auto-format", "tool-call", "error", {
-                    tool: name,
-                    error: String(error),
-                });
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error executing tool '${name}': ${error instanceof Error ? error.message : String(error)}`,
+                },
+            },
+            {
+                name: "format-check",
+                description: "Check if code is properly formatted without making changes",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Files to check formatting for",
                         },
-                    ],
-                    isError: true,
-                };
-            }
-        });
+                    },
+                },
+            },
+        ];
+        this.handlers = {
+            "auto-format": async (args) => this.handleAutoFormat(args),
+            "format-check": async (args) => this.handleFormatCheck(args),
+        };
+        this.setupToolHandlers();
+        frameworkLogger.log("mcps/auto-format", "initialize", "info");
     }
     async handleAutoFormat(args) {
         const files = args.files || [];
@@ -399,15 +358,10 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 - Errors: ${errorCount}
 - Formatters Applied: ${Object.keys(results.changes).length}`;
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        frameworkLogger.log("mcps/auto-format", "start", "info");
-    }
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XrayAutoFormatServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/auto-format", "run", "error", { error: String(error) }));
+    server.run("auto-format").catch((error) => frameworkLogger.log("mcps/auto-format", "run", "error", { error: String(error) }));
 }
 export { XrayAutoFormatServer };

package/dist/mcps/boot-orchestrator.server.d.ts

@@ -3,13 +3,12 @@
  *
  * Advanced initialization orchestration with dependency management and health monitoring
  */
-declare class XrayBootOrchestratorServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayBootOrchestratorServer extends XrayKnowledgeSkillBase {
     private bootStatus;
     private bootSequence;
     constructor();
     private initializeDependencies;
-    private setupToolHandlers;
     private handleExecuteBootSequence;
     private handleGetBootStatus;
     private handleInitializeComponent;
@@ -44,6 +43,5 @@ declare class XrayBootOrchestratorServer {
     private formatBootResults;
     private formatComponentStatus;
     private formatOverallStatus;
-    run(): Promise<void>;
 }
 export { XrayBootOrchestratorServer };

package/dist/mcps/boot-orchestrator.server.js

@@ -3,16 +3,13 @@
  *
  * Advanced initialization orchestration with dependency management and health monitoring
  */
-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 { execSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { resolveLogDir, resolveStateDir } from "../core/config-paths.js";
-class XrayBootOrchestratorServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayBootOrchestratorServer extends XrayKnowledgeSkillBase {
     bootStatus;
     // Boot sequence in dependency order
     bootSequence = [
@@ -29,13 +26,7 @@ class XrayBootOrchestratorServer {
         "framework-hooks",
     ];
     constructor() {
-        this.server = new Server({
-            name: "boot-orchestrator", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("boot-orchestrator", "2.0.1");
         this.bootStatus = {
             initialized: false,
             startTime: Date.now(),
@@ -45,6 +36,75 @@ class XrayBootOrchestratorServer {
         };
         // Initialize dependency map
         this.initializeDependencies();
+        this.tools = [
+            {
+                name: "execute-boot-sequence",
+                description: "Execute the complete 0xRay boot sequence with dependency resolution",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        config: { type: "object" },
+                        skipHealthChecks: { type: "boolean", default: false },
+                        parallelInit: { type: "boolean", default: true },
+                    },
+                },
+            },
+            {
+                name: "get-boot-status",
+                description: "Get comprehensive boot orchestrator status and health",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        detailed: { type: "boolean", default: false },
+                        component: { type: "string" },
+                    },
+                },
+            },
+            {
+                name: "initialize-component",
+                description: "Initialize a specific framework component",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        component: {
+                            type: "string",
+                            enum: this.bootSequence,
+                        },
+                        force: { type: "boolean", default: false },
+                    },
+                    required: ["component"],
+                },
+            },
+            {
+                name: "validate-boot-dependencies",
+                description: "Validate all boot dependencies and prerequisites",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        fix: { type: "boolean", default: false },
+                        verbose: { type: "boolean", default: false },
+                    },
+                },
+            },
+            {
+                name: "shutdown-framework",
+                description: "Gracefully shutdown framework components",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        force: { type: "boolean", default: false },
+                        saveState: { type: "boolean", default: true },
+                    },
+                },
+            },
+        ];
+        this.handlers = {
+            "execute-boot-sequence": async (args) => this.handleExecuteBootSequence(args),
+            "get-boot-status": async (args) => this.handleGetBootStatus(args),
+            "initialize-component": async (args) => this.handleInitializeComponent(args),
+            "validate-boot-dependencies": async (args) => this.handleValidateBootDependencies(args),
+            "shutdown-framework": async (args) => this.handleShutdownFramework(args),
+        };
         this.setupToolHandlers();
         void frameworkLogger.log("mcps/boot-orchestrator", "initialize", "info");
     }
@@ -88,93 +148,6 @@ class XrayBootOrchestratorServer {
             "orchestrator",
         ]);
     }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "execute-boot-sequence",
-                        description: "Execute the complete 0xRay boot sequence with dependency resolution",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                config: { type: "object" },
-                                skipHealthChecks: { type: "boolean", default: false },
-                                parallelInit: { type: "boolean", default: true },
-                            },
-                        },
-                    },
-                    {
-                        name: "get-boot-status",
-                        description: "Get comprehensive boot orchestrator status and health",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                detailed: { type: "boolean", default: false },
-                                component: { type: "string" },
-                            },
-                        },
-                    },
-                    {
-                        name: "initialize-component",
-                        description: "Initialize a specific framework component",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                component: {
-                                    type: "string",
-                                    enum: this.bootSequence,
-                                },
-                                force: { type: "boolean", default: false },
-                            },
-                            required: ["component"],
-                        },
-                    },
-                    {
-                        name: "validate-boot-dependencies",
-                        description: "Validate all boot dependencies and prerequisites",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                fix: { type: "boolean", default: false },
-                                verbose: { type: "boolean", default: false },
-                            },
-                        },
-                    },
-                    {
-                        name: "shutdown-framework",
-                        description: "Gracefully shutdown framework components",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                force: { type: "boolean", default: false },
-                                saveState: { type: "boolean", default: true },
-                            },
-                        },
-                    },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "execute-boot-sequence":
-                    return await this.handleExecuteBootSequence(args);
-                case "get-boot-status":
-                    return await this.handleGetBootStatus(args);
-                case "initialize-component":
-                    return await this.handleInitializeComponent(args);
-                case "validate-boot-dependencies":
-                    return await this.handleValidateBootDependencies(args);
-                case "shutdown-framework":
-                    return await this.handleShutdownFramework(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
-    }
     async handleExecuteBootSequence(args) {
         const config = args.config || {};
         const skipHealthChecks = args.skipHealthChecks || false;
@@ -839,15 +812,10 @@ ${results.warnings.length > 0 ? `**Warnings:**\n${results.warnings.map((w) => `
         }
         return response;
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        frameworkLogger.log("mcps/boot-orchestrator", "start", "success");
-    }
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XrayBootOrchestratorServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/boot-orchestrator", "run", "error", { error: String(error) }));
+    server.run("boot-orchestrator").catch((error) => frameworkLogger.log("mcps/boot-orchestrator", "run", "error", { error: String(error) }));
 }
 export { XrayBootOrchestratorServer };

package/dist/mcps/config/server-config-registry.js

@@ -16,14 +16,14 @@ import fs from 'fs';
 /**
  * Resolve the correct framework root and MCP servers path.
  * Priority:
- *   1. STRRAY_DEV_PATH env var (explicit dev override)
+ *   1. XRAY_DEV_PATH env var (explicit dev override)
  *   2. The "xray" field in the nearest package.json that declares it (works in both source tree and installed package)
  *   3. Safe fallback to node_modules/0xray/dist
  */
 function resolveFrameworkPaths() {
     // Highest priority: explicit environment override
-    if (process.env.STRRAY_DEV_PATH) {
-        const devPath = process.env.STRRAY_DEV_PATH;
+    if (process.env.XRAY_DEV_PATH) {
+        const devPath = process.env.XRAY_DEV_PATH || "";
         return {
             frameworkRoot: devPath,
             mcpServersPath: join(devPath, 'mcps'),

package/dist/mcps/enforcer-tools.server.d.ts

@@ -4,10 +4,9 @@
  * Converts enforcer-tools.ts functions into MCP server tools
  * Provides rule enforcement and validation capabilities via MCP protocol
  */
-declare class XrayEnforcerToolsServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayEnforcerToolsServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private ruleValidation;
     private codexEnforcement;
     private contextAnalysisValidation;
@@ -21,7 +20,6 @@ declare class XrayEnforcerToolsServer {
     private performQualityGateCheck;
     private simulateEnforcementStatus;
     private performPreCommitValidation;
-    run(): Promise<void>;
     private securityScan;
 }
 export default XrayEnforcerToolsServer;