0xray 3.1.0 → 3.2.0

package/dist/integrations/openclaw/config.js

@@ -3,7 +3,6 @@
  *
  * Handles loading, validation, and management of OpenClaw integration configuration.
  *
- * @version 1.0.0
  * @since 2026-03-14
  */
 import * as fs from 'fs';
@@ -54,7 +53,7 @@ export class OpenClawConfigLoader {
     loadedAt = 0;
     constructor(configPath) {
         this.configPath = configPath ||
-            path.join(process.cwd(), '.strray', 'config', 'openclaw.json');
+            path.join(process.cwd(), '.xray', 'config', 'openclaw.json');
     }
     /**
      * Load configuration from file with environment variable overrides

package/dist/integrations/openclaw/hooks/{strray-hooks.js → xray-hooks.js}

@@ -4,7 +4,6 @@
  * Integrates OpenClaw with 0xRay's tool.before and tool.after hooks
  * to send tool execution events to OpenClaw Gateway.
  *
- * @version 1.0.0
  * @since 2026-03-14
  */
 /**

package/dist/integrations/openclaw/index.js

@@ -3,7 +3,6 @@
  *
  * Combines all OpenClaw integration components into a single interface.
  *
- * @version 1.0.0
  * @since 2026-03-14
  */
 import { BaseIntegration } from '../base/index.js';
@@ -12,7 +11,7 @@ import { OpenClawClient } from './client.js';
 import { XrayAPIServer } from './api-server.js';
 import { initializeGovernanceIntegration } from '../governance/index.js';
 import { featuresConfigLoader } from '../../core/features-config.js';
-import { OpenClawHooksManager } from './hooks/strray-hooks.js';
+import { OpenClawHooksManager } from './hooks/xray-hooks.js';
 import { mcpClientManager } from '../../mcps/mcp-client.js';
 /**
  * Main OpenClaw Integration class
@@ -348,4 +347,4 @@ export * from './types.js';
 export * from './config.js';
 export * from './client.js';
 export * from './api-server.js';
-export { OpenClawHooksManager } from './hooks/strray-hooks.js';
+export { OpenClawHooksManager } from './hooks/xray-hooks.js';

package/dist/integrations/openclaw/types.js

@@ -4,7 +4,6 @@
  * TypeScript interfaces for OpenClaw Gateway Protocol v3
  * and 0xRay integration components.
  *
- * @version 1.0.0
  * @since 2026-03-14
  */
 // ============================================================================
@@ -37,9 +36,9 @@ export var OpenClawErrorCode;
     OpenClawErrorCode["SKILL_LOAD_FAILED"] = "SKILL_LOAD_FAILED";
     OpenClawErrorCode["SKILL_EXECUTION_FAILED"] = "SKILL_EXECUTION_FAILED";
     // 0xRay errors
-    OpenClawErrorCode["STRINGRAY_UNAVAILABLE"] = "STRINGRAY_UNAVAILABLE";
-    OpenClawErrorCode["STRINGRAY_TIMEOUT"] = "STRINGRAY_TIMEOUT";
-    OpenClawErrorCode["STRINGRAY_ERROR"] = "STRINGRAY_ERROR";
+    OpenClawErrorCode["XRAY_UNAVAILABLE"] = "XRAY_UNAVAILABLE";
+    OpenClawErrorCode["XRAY_TIMEOUT"] = "XRAY_TIMEOUT";
+    OpenClawErrorCode["XRAY_ERROR"] = "XRAY_ERROR";
     // Configuration errors
     OpenClawErrorCode["CONFIG_INVALID"] = "CONFIG_INVALID";
     OpenClawErrorCode["CONFIG_MISSING"] = "CONFIG_MISSING";

package/dist/integrations/plugins/index.js

@@ -4,7 +4,6 @@
  * Industrial-grade plugin system for 0xRay.
  * Provides lifecycle management, security, metrics, and extensibility.
  *
- * @version 1.1.0
  */
 export { PluginIntegration, PluginType, PluginState, DEFAULT_PLUGIN_CONFIG, parseYamlManifest, validatePluginManifest, satisfiesVersion, } from "./plugin-integration.js";
 export { PluginRegistry, } from "./plugin-registry.js";

package/dist/integrations/plugins/plugin-integration.js

@@ -14,7 +14,6 @@
  * - Graceful shutdown with retry logic
  * - Plugin isolation with process spawning
  *
- * @version 1.1.0
  */
 import * as fs from "fs";
 import * as path from "path";
@@ -245,7 +244,7 @@ export class PluginIntegration extends BaseIntegration {
             author: parsed.author ? String(parsed.author) : undefined,
             homepage: parsed.homepage ? String(parsed.homepage) : undefined,
             repository: parsed.repository ? String(parsed.repository) : undefined,
-            minStringrayVersion: parsed.minStringrayVersion ? String(parsed.minStringrayVersion) : undefined,
+            minXrayVersion: parsed.minXrayVersion ? String(parsed.minXrayVersion) : undefined,
             runtime: parsed.runtime,
             tools: parsed.tools,
             capabilities: parsed.capabilities,

package/dist/integrations/plugins/plugin-registry.js

@@ -14,7 +14,6 @@
  * - Metrics aggregation
  * - Event-driven architecture
  *
- * @version 1.1.0
  */
 import { EventEmitter } from "events";
 import * as fs from "fs";
@@ -172,7 +171,7 @@ export class PluginRegistry extends EventEmitter {
                 author: parsed.author ? String(parsed.author) : undefined,
                 homepage: parsed.homepage ? String(parsed.homepage) : undefined,
                 repository: parsed.repository ? String(parsed.repository) : undefined,
-                minStringrayVersion: parsed.minStringrayVersion ? String(parsed.minStringrayVersion) : undefined,
+                minXrayVersion: parsed.minXrayVersion ? String(parsed.minXrayVersion) : undefined,
                 runtime: parsed.runtime,
                 tools: parsed.tools,
                 capabilities: parsed.capabilities,

package/dist/mcps/agent-resolver.js

@@ -4,7 +4,6 @@
  * Resolves agent configurations from the 0xRay registry.
  * Used by the integration layer to programmatically access agent configs.
  *
- * @version 1.1.0
  * @since 2026-02-14
  */
 import * as fs from "fs";

package/dist/mcps/architect-tools.server.js

@@ -4,153 +4,141 @@
  * Converts architect-tools.ts functions into MCP server tools
  * Provides contextual analysis capabilities via MCP protocol
  */
-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 { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+import * as fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { contextAnalysis as architectContextAnalysis, codebaseStructure as architectCodebaseStructure, dependencyAnalysis as architectDependencyAnalysis, architectureAssessment as architectArchitectureAssessment, } from "../architect/architect-tools.js";
-class XrayArchitectToolsServer {
-    server;
+class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "architect-tools", version: "1.22.67",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        frameworkLogger.log("mcps/architect-tools", "init", "info", { message: "0xRay Architect Tools MCP Server initialized" });
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "context-analysis",
-                        description: "Perform comprehensive codebase intelligence gathering including structure analysis, dependency mapping, and architectural pattern recognition",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: {
-                                    type: "string",
-                                    description: "Root directory of the project to analyze",
-                                },
-                                depth: {
-                                    type: "string",
-                                    enum: ["overview", "detailed", "comprehensive"],
-                                    default: "detailed",
-                                    description: "Analysis depth level",
-                                },
-                                includeFiles: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific files to include in analysis",
-                                },
-                            },
-                            required: ["projectRoot"],
+        super("architect-tools", "3.1.0");
+        this.tools = [
+            {
+                name: "context-analysis",
+                description: "Perform comprehensive codebase intelligence gathering including structure analysis, dependency mapping, and architectural pattern recognition",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectRoot: {
+                            type: "string",
+                            description: "Root directory of the project to analyze",
+                        },
+                        depth: {
+                            type: "string",
+                            enum: ["overview", "detailed", "comprehensive"],
+                            default: "detailed",
+                            description: "Analysis depth level",
+                        },
+                        includeFiles: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific files to include in analysis",
                         },
                     },
-                    {
-                        name: "codebase-structure",
-                        description: "Analyze file organization, module distribution, and directory hierarchy with optional metrics",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: {
-                                    type: "string",
-                                    description: "Root directory of the project",
-                                },
-                                includeMetrics: {
-                                    type: "boolean",
-                                    default: true,
-                                    description: "Include detailed metrics",
-                                },
-                                maxDepth: {
-                                    type: "number",
-                                    default: 10,
-                                    description: "Maximum directory depth to analyze",
-                                },
-                            },
-                            required: ["projectRoot"],
+                    required: ["projectRoot"],
+                },
+            },
+            {
+                name: "codebase-structure",
+                description: "Analyze file organization, module distribution, and directory hierarchy with optional metrics",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectRoot: {
+                            type: "string",
+                            description: "Root directory of the project",
+                        },
+                        includeMetrics: {
+                            type: "boolean",
+                            default: true,
+                            description: "Include detailed metrics",
+                        },
+                        maxDepth: {
+                            type: "number",
+                            default: 10,
+                            description: "Maximum directory depth to analyze",
                         },
                     },
-                    {
-                        name: "dependency-analysis",
-                        description: "Map component dependencies, identify coupling patterns, and assess architectural relationships",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: {
-                                    type: "string",
-                                    description: "Root directory of the project",
-                                },
-                                focusAreas: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific areas to focus dependency analysis on",
-                                },
-                                includeGraphs: {
-                                    type: "boolean",
-                                    default: true,
-                                    description: "Include dependency graphs in output",
-                                },
-                            },
-                            required: ["projectRoot"],
+                    required: ["projectRoot"],
+                },
+            },
+            {
+                name: "dependency-analysis",
+                description: "Map component dependencies, identify coupling patterns, and assess architectural relationships",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectRoot: {
+                            type: "string",
+                            description: "Root directory of the project",
+                        },
+                        focusAreas: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific areas to focus dependency analysis on",
+                        },
+                        includeGraphs: {
+                            type: "boolean",
+                            default: true,
+                            description: "Include dependency graphs in output",
                         },
                     },
-                    {
-                        name: "architecture-assessment",
-                        description: "Evaluate overall architectural health with scores, issues, and improvement recommendations",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: {
-                                    type: "string",
-                                    description: "Root directory of the project",
-                                },
-                                assessmentType: {
-                                    type: "string",
-                                    enum: ["quick", "comprehensive"],
-                                    default: "comprehensive",
-                                    description: "Type of assessment to perform",
-                                },
-                                focusMetrics: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: [
-                                            "complexity",
-                                            "coupling",
-                                            "cohesion",
-                                            "testability",
-                                            "scalability",
-                                        ],
-                                    },
-                                    description: "Specific metrics to focus assessment on",
-                                },
+                    required: ["projectRoot"],
+                },
+            },
+            {
+                name: "architecture-assessment",
+                description: "Evaluate overall architectural health with scores, issues, and improvement recommendations",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectRoot: {
+                            type: "string",
+                            description: "Root directory of the project",
+                        },
+                        assessmentType: {
+                            type: "string",
+                            enum: ["quick", "comprehensive"],
+                            default: "comprehensive",
+                            description: "Type of assessment to perform",
+                        },
+                        focusMetrics: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: [
+                                    "complexity",
+                                    "coupling",
+                                    "cohesion",
+                                    "testability",
+                                    "scalability",
+                                ],
                             },
-                            required: ["projectRoot"],
+                            description: "Specific metrics to focus assessment on",
                         },
                     },
-                ],
-            };
-        });
+                    required: ["projectRoot"],
+                },
+            },
+        ];
+        this.handlers = {
+            "context-analysis": async (args) => this.contextAnalysis(args),
+            "codebase-structure": async (args) => this.codebaseStructure(args),
+            "dependency-analysis": async (args) => this.dependencyAnalysis(args),
+            "architecture-assessment": async (args) => this.architectureAssessment(args),
+        };
+        this.setupToolHandlers();
+        frameworkLogger.log("mcps/architect-tools", "init", "info", { message: "0xRay Architect Tools MCP Server initialized" });
+    }
+    setupToolHandlers() {
+        this.setupListToolsHandler();
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
+            const handler = this.handlers[name];
+            if (!handler)
+                throw new Error(`Unknown tool: ${name}`);
             try {
-                switch (name) {
-                    case "context-analysis":
-                        return await this.contextAnalysis(args);
-                    case "codebase-structure":
-                        return await this.codebaseStructure(args);
-                    case "dependency-analysis":
-                        return await this.dependencyAnalysis(args);
-                    case "architecture-assessment":
-                        return await this.architectureAssessment(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
+                return await handler(args);
             }
             catch (error) {
                 frameworkLogger.log("mcps/architect-tools", "tool", "error", { tool: name, error: String(error) });
@@ -216,61 +204,8 @@ class XrayArchitectToolsServer {
             ],
         };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        frameworkLogger.log("mcps/architect-tools", "start", "info");
-        const cleanup = async (signal) => {
-            frameworkLogger.log("mcps/architect-tools", "shutdown", "info", { signal });
-            // Set a timeout to force exit if graceful shutdown fails
-            const timeout = setTimeout(() => {
-                frameworkLogger.log("mcps/architect-tools", "shutdown", "error", { message: "Graceful shutdown timeout, forcing exit..." });
-                process.exit(1);
-            }, 5000); // 5 second timeout
-            try {
-                if (this.server && typeof this.server.close === "function") {
-                    await this.server.close();
-                }
-                clearTimeout(timeout);
-                frameworkLogger.log("mcps/architect-tools", "shutdown", "success");
-                process.exit(0);
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                frameworkLogger.log("mcps/architect-tools", "shutdown", "error", { message: `Error during server shutdown: ${String(error)}` });
-                process.exit(1);
-            }
-        };
-        // Handle multiple shutdown signals
-        process.on("SIGINT", () => cleanup("SIGINT"));
-        process.on("SIGTERM", () => cleanup("SIGTERM"));
-        process.on("SIGHUP", () => cleanup("SIGHUP"));
-        // Monitor parent process (opencode) and shutdown if it dies
-        const checkParent = () => {
-            try {
-                process.kill(process.ppid, 0); // Check if parent is alive
-                setTimeout(checkParent, 1000); // Check again in 1 second
-            }
-            catch (error) {
-                // Parent process died, shut down gracefully
-                frameworkLogger.log("mcps/architect-tools", "parent-death", "info");
-                cleanup("parent-process-death");
-            }
-        };
-        // Start monitoring parent process
-        setTimeout(checkParent, 2000); // Start checking after 2 seconds
-        // Handle uncaught exceptions and unhandled rejections
-        process.on("uncaughtException", (error) => {
-            frameworkLogger.log("mcps/architect-tools", "uncaughtException", "error", { error: String(error) });
-            cleanup("uncaughtException");
-        });
-        process.on("unhandledRejection", (reason, promise) => {
-            frameworkLogger.log("mcps/architect-tools", "unhandledRejection", "error", { error: String(reason) });
-            cleanup("unhandledRejection");
-        });
-    }
 }
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new XrayArchitectToolsServer();
     server.run().catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
 }

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

@@ -3,87 +3,74 @@
  *
  * 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 { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 import { execFileSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
-class XrayAutoFormatServer {
-    server;
+class XrayAutoFormatServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "auto-format", version: "1.22.67",
-        }, {
-            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", "3.1.0");
+        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)",
+                        },
+                        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",
                         },
                     },
-                    {
-                        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",
-                                },
-                            },
+                },
+            },
+            {
+                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",
                         },
                     },
-                ],
-            };
-        });
-        // Handle tool calls
+                },
+            },
+        ];
+        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");
+    }
+    setupToolHandlers() {
+        this.setupListToolsHandler();
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
+            const handler = this.handlers[name];
+            if (!handler)
+                throw new Error(`Unknown tool: ${name}`);
             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}`);
-                }
+                return await handler(args);
             }
             catch (error) {
                 frameworkLogger.log("mcps/auto-format", "tool-call", "error", {
@@ -399,14 +386,9 @@ ${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]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new XrayAutoFormatServer();
     server.run().catch((error) => frameworkLogger.log("mcps/auto-format", "run", "error", { error: String(error) }));
 }