0xray 3.0.12 → 3.1.0

package/dist/mcps/governance.server.js

@@ -11,7 +11,6 @@
  * It always runs proposals through the three real skill servers
  * and the Dynamo Solar SSOT filter (required by default).
  */
-import { randomUUID } from "crypto";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -19,26 +18,24 @@ import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import * as fs from "fs";
+import * as path from "path";
 import { fileURLToPath } from "url";
-import { handleGovernRequest } from "../nucleus/index.js";
+import { randomUUID } from "crypto";
+import { getGovernanceService } from "../governance/governance-service.js";
 import { getCodexPolicyService } from "../governance/codex-policy.service.js";
 import { initializeGovernanceIntegration } from "../integrations/governance/index.js";
 import { featuresConfigLoader } from "../core/features-config.js";
 class GovernanceServer {
     server;
     constructor() {
-        this.server = this.createServer();
-    }
-    createServer() {
-        const server = new Server({
-            name: "governance", version: "3.0.11",
+        this.server = new Server({
+            name: "governance", version: "1.22.67",
         }, {
             capabilities: {
                 tools: {},
             },
         });
-        this.setupToolHandlersOn(server);
-        return server;
+        this.setupToolHandlers();
     }
     validateGovernProposalsArgs(value) {
         if (!value || typeof value !== 'object') {
@@ -62,17 +59,8 @@ class GovernanceServer {
             if (typeof p.description !== 'string') {
                 throw new Error(`proposals[${i}].description must be a string`);
             }
-            if (typeof p.source !== 'string' || !p.source) {
-                throw new Error(`proposals[${i}].source is required — set to "inference", "reflection", "manual", "ci", "phase-planning", or "metamorphosis"`);
-            }
         }
-        return {
-            ...value,
-            proposals: obj.proposals.map((p) => ({
-                ...p,
-                source: p.source,
-            })),
-        };
+        return value;
     }
     validateGovernReflectionArgs(value) {
         if (!value || typeof value !== 'object') {
@@ -80,8 +68,8 @@ class GovernanceServer {
         }
         return value;
     }
-    setupToolHandlersOn(server) {
-        server.setRequestHandler(ListToolsRequestSchema, async () => {
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
             return {
                 tools: [
                     {
@@ -110,7 +98,7 @@ class GovernanceServer {
                                             source: { type: "string" },
                                             confidence: { type: "number" },
                                         },
-                                        required: ["type", "title", "description", "source"],
+                                        required: ["type", "title", "description"],
                                     },
                                     description: "List of proposals to govern",
                                 },
@@ -172,7 +160,7 @@ class GovernanceServer {
                 ],
             };
         });
-        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
             try {
                 switch (name) {
@@ -204,6 +192,7 @@ class GovernanceServer {
         });
     }
     async handleGovernProposals(args) {
+        const service = getGovernanceService();
         const request = {
             proposals: args.proposals.map((p, i) => ({
                 id: p.id || `prop-${Date.now()}-${i}`,
@@ -211,18 +200,18 @@ class GovernanceServer {
                 title: p.title,
                 description: p.description,
                 evidence: p.evidence || [],
-                source: p.source,
+                source: "manual",
                 confidence: p.confidence || 0.8,
             })),
             context: args.context || {},
             options: {
-                requireExternalDynamo: args.options?.require_external ?? !process.env.XRAY_LOCAL_MODE,
+                requireExternalDynamo: args.options?.require_external ?? true,
             },
         };
-        frameworkLogger.log("governance-mcp", "delegating-to-kernel", "info", {
+        frameworkLogger.log("governance-mcp", "delegating-to-governance-service", "info", {
             proposalCount: request.proposals.length,
         });
-        const response = await handleGovernRequest(request);
+        const response = await service.govern(request);
         return {
             content: [
                 {
@@ -406,8 +395,11 @@ class GovernanceServer {
      */
     async runHttp(port = parseInt(process.env.MCP_PORT ?? "3100", 10)) {
         await this.initializeGovernance();
-        const app = createMcpExpressApp({ host: '0.0.0.0' });
-        const transports = {};
+        const app = createMcpExpressApp();
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+        });
+        await this.server.connect(transport);
         const apiKey = process.env.GOVERNANCE_API_KEY;
         if (apiKey) {
             frameworkLogger.log("governance-mcp", "api-key-auth-enabled", "info", {});
@@ -427,30 +419,9 @@ class GovernanceServer {
             }
             next();
         });
-        const handlePost = async (req, res) => {
+        app.post("/mcp", async (req, res) => {
             try {
-                const sessionId = req.headers["mcp-session-id"];
-                if (sessionId && transports[sessionId]) {
-                    await transports[sessionId].handleRequest(req, res, req.body);
-                    return;
-                }
-                if (!sessionId && req.body?.method === "initialize") {
-                    const transport = new StreamableHTTPServerTransport({
-                        sessionIdGenerator: () => randomUUID(),
-                        enableJsonResponse: true,
-                        onsessioninitialized: (newId) => {
-                            transports[newId] = transport;
-                            frameworkLogger.log("governance-mcp", "session-created", "info", { sessionId: newId });
-                        },
-                    });
-                    const server = this.createServer();
-                    await server.connect(transport);
-                    await transport.handleRequest(req, res, req.body);
-                    return;
-                }
-                res.status(400).json({
-                    jsonrpc: "2.0", error: { code: -32000, message: "Bad Request: No valid session ID provided" }, id: null,
-                });
+                await transport.handleRequest(req, res, req.body);
             }
             catch (error) {
                 frameworkLogger.log("governance-mcp", "http-handler-error", "error", { error: String(error) });
@@ -458,47 +429,20 @@ class GovernanceServer {
                     res.status(500).json({ jsonrpc: "2.0", error: { code: -32603, message: "Internal error" }, id: null });
                 }
             }
-        };
-        const handleGet = async (req, res) => {
-            try {
-                const sessionId = req.headers["mcp-session-id"];
-                if (sessionId && transports[sessionId]) {
-                    await transports[sessionId].handleRequest(req, res);
-                    return;
-                }
-                const transport = new StreamableHTTPServerTransport({
-                    sessionIdGenerator: () => randomUUID(),
-                    enableJsonResponse: true,
-                    onsessioninitialized: (newId) => {
-                        transports[newId] = transport;
-                        frameworkLogger.log("governance-mcp", "session-created", "info", { sessionId: newId });
-                    },
-                });
-                const server = this.createServer();
-                await server.connect(transport);
-                await transport.handleRequest(req, res);
-            }
-            catch (error) {
-                frameworkLogger.log("governance-mcp", "http-get-error", "error", { error: String(error) });
-                if (!res.headersSent) {
-                    res.status(500).json({ jsonrpc: "2.0", error: { code: -32603, message: "Internal error" }, id: null });
-                }
-            }
-        };
-        app.post("/mcp", handlePost);
-        app.get("/mcp", handleGet);
+        });
         app.get("/health", (_req, res) => {
             res.json({ status: "ok", server: "governance" });
         });
         app.listen(port, () => {
             frameworkLogger.log("governance-mcp", "http-listening", "info", { port });
         });
-        process.on("SIGINT", () => { process.exit(0); });
-        process.on("SIGTERM", () => { process.exit(0); });
+        process.on("SIGINT", () => { transport.close(); process.exit(0); });
+        process.on("SIGTERM", () => { transport.close(); process.exit(0); });
     }
 }
-// Start the server if this file is run directly (realpath handles /var → /private/var on macOS)
-if (process.argv[1] && fs.realpathSync(fileURLToPath(import.meta.url)) === fs.realpathSync(process.argv[1])) {
+// Start the server if this file is run directly
+const entryPoint = path.resolve(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];
     const port = parseInt(cliPort ?? process.env.MCP_PORT ?? "", 10);
@@ -518,4 +462,3 @@ if (process.argv[1] && fs.realpathSync(fileURLToPath(import.meta.url)) === fs.re
     }
 }
 export { GovernanceServer };
-//# sourceMappingURL=governance.server.js.map

package/dist/mcps/in-process-skill-registry.js

@@ -1,8 +1,6 @@
 import { XrayCodeReviewServer } from "./knowledge-skills/code-review.server.js";
 import { XraySecurityAuditServer } from "./knowledge-skills/security-audit.server.js";
 import { XrayLibrarianServer } from "./researcher.server.js";
-import { pluginRegistry } from "../nucleus/plugin-registry.js";
-import { frameworkLogger } from "../core/framework-logger.js";
 const instances = new Map();
 function getCodeReview() {
     if (!instances.has("code-review")) {
@@ -37,20 +35,6 @@ const registry = {
     "researcher": getResearcher,
 };
 export async function callInProcessSkill(serverName, toolName, args) {
-    // Phase 2D: try pluginRegistry first for any registered tool plugin
-    if (pluginRegistry.hasToolPlugin(serverName)) {
-        try {
-            const result = await pluginRegistry.callSkillTool(serverName, toolName, args);
-            return result;
-        }
-        catch {
-            frameworkLogger.log('in-process-skill-registry', 'plugin-fallback', 'info', {
-                server: serverName,
-                tool: toolName,
-                message: 'Plugin dispatch failed, falling back to in-process handler',
-            });
-        }
-    }
     const factory = registry[serverName];
     if (!factory) {
         throw new Error(`No in-process handler registered for server: ${serverName}`);
@@ -62,4 +46,3 @@ export async function callInProcessSkill(serverName, toolName, args) {
     const handler = factory();
     return handler.analyzeProposal(args);
 }
-//# sourceMappingURL=in-process-skill-registry.js.map

package/dist/mcps/index.js

@@ -62,4 +62,3 @@ export function getRegisteredServers() {
 export function getUnregisteredServers() {
     return MCP_SERVERS.filter(s => !s.registered);
 }
-//# sourceMappingURL=index.js.map

package/dist/mcps/knowledge-skills/api-design.server.js

@@ -4,52 +4,65 @@
  * Knowledge skill for API design patterns, RESTful conventions,
  * GraphQL schema design, and API documentation standards
  */
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { pluginRegistry } from "../../nucleus/plugin-registry.js";
-class XrayApiDesignServer 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 XrayApiDesignServer {
+    server;
     constructor() {
-        super("api-design", "2.0.1");
-        this.tools = [
-            {
-                name: "design-api-endpoints",
-                description: "Design RESTful API endpoints with proper resource modeling",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        resource: { type: "string" },
-                        operations: { type: "array", items: { type: "string" } },
-                        relationships: { type: "array", items: { type: "string" } },
-                    },
-                    required: ["resource"],
-                },
+        this.server = new Server({
+            name: "api-design", version: "1.22.67",
+        }, {
+            capabilities: {
+                tools: {},
             },
-            {
-                name: "validate-api-design",
-                description: "Validate API design against RESTful principles and best practices",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        endpoints: { type: "array", items: { type: "string" } },
-                        standards: { type: "array", items: { type: "string" } },
-                    },
-                    required: ["endpoints"],
-                },
-            },
-        ];
-        this.handlers = {
-            "design-api-endpoints": async (args) => this.designApiEndpoints(args),
-            "validate-api-design": async (args) => this.validateApiDesign(args),
-        };
+        });
         this.setupToolHandlers();
-        pluginRegistry.registerToolPlugin({
-            name: "api-design",
-            callTool: async (toolName, args) => {
-                const handler = this.handlers[toolName];
-                if (!handler)
-                    throw new Error(`Unknown tool: ${toolName}`);
-                return handler(args);
-            },
+        // Server initialization - removed unnecessary startup logging
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "design-api-endpoints",
+                        description: "Design RESTful API endpoints with proper resource modeling",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                resource: { type: "string" },
+                                operations: { type: "array", items: { type: "string" } },
+                                relationships: { type: "array", items: { type: "string" } },
+                            },
+                            required: ["resource"],
+                        },
+                    },
+                    {
+                        name: "validate-api-design",
+                        description: "Validate API design against RESTful principles and best practices",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                endpoints: { type: "array", items: { type: "string" } },
+                                standards: { type: "array", items: { type: "string" } },
+                            },
+                            required: ["endpoints"],
+                        },
+                    },
+                ],
+            };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            switch (name) {
+                case "design-api-endpoints":
+                    return await this.designApiEndpoints(args);
+                case "validate-api-design":
+                    return await this.validateApiDesign(args);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
         });
     }
     async designApiEndpoints(args) {
@@ -93,10 +106,18 @@ class XrayApiDesignServer extends XrayKnowledgeSkillBase {
             ],
         };
     }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        // Use centralized shutdown handler
+        createGracefulShutdown({
+            serverName: "api-design.server",
+            server: this.server,
+        });
+    }
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XrayApiDesignServer();
-    server.run("api-design").catch((err) => { frameworkLogger.log("api-design", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
+    server.run().catch(() => { });
 }
 export default XrayApiDesignServer;
-//# sourceMappingURL=api-design.server.js.map

package/dist/mcps/knowledge-skills/architecture-patterns.server.js

@@ -1,53 +1,73 @@
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { pluginRegistry } from "../../nucleus/plugin-registry.js";
-class XrayArchitecturePatternsServer extends XrayKnowledgeSkillBase {
+/**
+ * xray Architecture Patterns MCP Server
+ *
+ * Knowledge skill for architectural pattern recognition,
+ * design pattern recommendations, and system architecture guidance
+ */
+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 XrayArchitecturePatternsServer {
+    server;
     constructor() {
-        super("architecture-patterns", "2.0.1");
-        this.tools = [
-            {
-                name: "analyze-architecture",
-                description: "Analyze current system architecture and identify patterns",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        projectRoot: { type: "string" },
-                        focusPatterns: { type: "array", items: { type: "string" } },
-                    },
-                    required: ["projectRoot"],
-                },
+        this.server = new Server({
+            name: "architecture-patterns", version: "1.22.67",
+        }, {
+            capabilities: {
+                tools: {},
             },
-            {
-                name: "recommend-patterns",
-                description: "Recommend architectural patterns for specific use cases",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        useCase: { type: "string" },
-                        constraints: { type: "array", items: { type: "string" } },
-                        scale: { type: "string", enum: ["small", "medium", "large"] },
-                    },
-                    required: ["useCase"],
-                },
-            },
-        ];
-        this.handlers = {
-            "analyze-architecture": async (args) => this.analyzeArchitecture(args),
-            "recommend-patterns": async (args) => this.recommendPatterns(args),
-        };
+        });
         this.setupToolHandlers();
-        pluginRegistry.registerToolPlugin({
-            name: "architecture-patterns",
-            callTool: async (toolName, args) => {
-                const handler = this.handlers[toolName];
-                if (!handler)
-                    throw new Error(`Unknown tool: ${toolName}`);
-                return handler(args);
-            },
+        // Server initialization - removed unnecessary startup logging
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "analyze-architecture",
+                        description: "Analyze current system architecture and identify patterns",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                projectRoot: { type: "string" },
+                                focusPatterns: { type: "array", items: { type: "string" } },
+                            },
+                            required: ["projectRoot"],
+                        },
+                    },
+                    {
+                        name: "recommend-patterns",
+                        description: "Recommend architectural patterns for specific use cases",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                useCase: { type: "string" },
+                                constraints: { type: "array", items: { type: "string" } },
+                                scale: { type: "string", enum: ["small", "medium", "large"] },
+                            },
+                            required: ["useCase"],
+                        },
+                    },
+                ],
+            };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            switch (name) {
+                case "analyze-architecture":
+                    return await this.analyzeArchitecture(args);
+                case "recommend-patterns":
+                    return await this.recommendPatterns(args);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
         });
     }
     async analyzeArchitecture(args) {
         const { projectRoot, focusPatterns } = args;
+        // Simplified architecture analysis
         const analysis = {
             patterns: ["MVC", "Repository"],
             recommendations: ["Consider microservices for scaling"],
@@ -76,10 +96,18 @@ class XrayArchitecturePatternsServer extends XrayKnowledgeSkillBase {
             ],
         };
     }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        // Use centralized shutdown handler
+        createGracefulShutdown({
+            serverName: "architecture-patterns.server",
+            server: this.server,
+        });
+    }
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XrayArchitecturePatternsServer();
-    server.run("architecture-patterns.server").catch((err) => { frameworkLogger.log("architecture-patterns", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
+    server.run().catch(() => { });
 }
 export default XrayArchitecturePatternsServer;
-//# sourceMappingURL=architecture-patterns.server.js.map