0xray 2.1.2 → 2.1.4

package/dist/integrations/openclaw/hooks/xray-hooks.js

@@ -7,6 +7,7 @@
  * @version 1.0.0
  * @since 2026-03-14
  */
+import { frameworkLogger } from '../../../core/framework-logger.js';
 /**
  * OpenClaw Hooks Manager
  */
@@ -16,7 +17,6 @@ export class OpenClawHooksManager {
     initialized = false;
     toolBeforeCallbacks = new Set();
     toolAfterCallbacks = new Set();
-    logger;
     // Offline event buffering
     eventQueue = [];
     maxQueueSize = 100;
@@ -30,7 +30,6 @@ export class OpenClawHooksManager {
             includeResult: config.includeResult ?? true,
             ...(config.toolFilter ? { toolFilter: config.toolFilter } : {}),
         };
-        this.logger = console;
     }
     /**
      * Set the OpenClaw client
@@ -43,19 +42,19 @@ export class OpenClawHooksManager {
      */
     async initialize() {
         if (this.initialized) {
-            this.logger.warn('[OpenClawHooks] Already initialized');
+            frameworkLogger.log('openclaw-hooks', 'Already initialized', 'warning', {});
             return;
         }
         if (!this.config.enabled) {
-            this.logger.info('[OpenClawHooks] Hooks disabled in configuration');
+            frameworkLogger.log('openclaw-hooks', 'Hooks disabled in configuration', 'info', {});
             return;
         }
-        this.logger.info('[OpenClawHooks] Initializing 0xRay tool hooks...');
+        frameworkLogger.log('openclaw-hooks', 'Initializing 0xRay tool hooks...', 'info', {});
         // Register with 0xRay's event system
         // The integration should call registerToolBefore and registerToolAfter
         // to connect to 0xRay's actual tool execution events
         this.initialized = true;
-        this.logger.info('[OpenClawHooks] Hooks initialized successfully');
+        frameworkLogger.log('openclaw-hooks', 'Hooks initialized successfully', 'info', {});
     }
     /**
      * Register a callback for tool.before events
@@ -121,13 +120,13 @@ export class OpenClawHooksManager {
                     await callback(event);
                 }
                 catch (error) {
-                    this.logger.error('[OpenClawHooks] Callback error in tool.before:', error);
+                    frameworkLogger.log('openclaw-hooks', 'Callback error in tool.before:', 'error', { error });
                 }
             }
-            this.logger.debug(`[OpenClawHooks] tool.before: ${event.toolName}`);
+            frameworkLogger.log('openclaw-hooks', `tool.before: ${event.toolName}`, 'debug', {});
         }
         catch (error) {
-            this.logger.error('[OpenClawHooks] Error handling tool.before:', error);
+            frameworkLogger.log('openclaw-hooks', 'Error handling tool.before:', 'error', { error });
         }
     }
     /**
@@ -171,13 +170,13 @@ export class OpenClawHooksManager {
                     await callback(event);
                 }
                 catch (error) {
-                    this.logger.error('[OpenClawHooks] Callback error in tool.after:', error);
+                    frameworkLogger.log('openclaw-hooks', 'Callback error in tool.after:', 'error', { error });
                 }
             }
-            this.logger.debug(`[OpenClawHooks] tool.after: ${event.toolName} (${event.error ? 'error' : 'success'})`);
+            frameworkLogger.log('openclaw-hooks', `tool.after: ${event.toolName} (${event.error ? 'error' : 'success'})`, 'debug', {});
         }
         catch (error) {
-            this.logger.error('[OpenClawHooks] Error handling tool.after:', error);
+            frameworkLogger.log('openclaw-hooks', 'Error handling tool.after:', 'error', { error });
         }
     }
     /**
@@ -187,10 +186,10 @@ export class OpenClawHooksManager {
         if (this.eventQueue.length >= this.maxQueueSize) {
             // Remove oldest event to make room
             this.eventQueue.shift();
-            this.logger.warn('[OpenClawHooks] Event queue full, dropping oldest event');
+            frameworkLogger.log('openclaw-hooks', 'Event queue full, dropping oldest event', 'warning', {});
         }
         this.eventQueue.push({ type, event });
-        this.logger.debug(`[OpenClawHooks] Queued ${type} event (queue size: ${this.eventQueue.length})`);
+        frameworkLogger.log('openclaw-hooks', `Queued ${type} event (queue size: ${this.eventQueue.length})`, 'debug', {});
     }
     /**
      * Flush queued events to OpenClaw Gateway
@@ -213,12 +212,12 @@ export class OpenClawHooksManager {
                     }
                 }
                 catch (error) {
-                    this.logger.error(`[OpenClawHooks] Failed to send queued ${item.type} event:`, error);
+                    frameworkLogger.log('openclaw-hooks', `Failed to send queued ${item.type} event:`, 'error', { error });
                     // Re-queue failed events
                     this.eventQueue.push(item);
                 }
             }
-            this.logger.info(`[OpenClawHooks] Flushed ${queue.length} queued events`);
+            frameworkLogger.log('openclaw-hooks', `Flushed ${queue.length} queued events`, 'info', {});
         }
         finally {
             this.isFlushing = false;
@@ -235,7 +234,7 @@ export class OpenClawHooksManager {
      */
     async handleReconnect() {
         if (this.eventQueue.length > 0) {
-            this.logger.info(`[OpenClawHooks] Client reconnected, flushing ${this.eventQueue.length} queued events...`);
+            frameworkLogger.log('openclaw-hooks', `Client reconnected, flushing ${this.eventQueue.length} queued events...`, 'info', {});
             await this.flushEventQueue();
         }
     }
@@ -248,7 +247,7 @@ export class OpenClawHooksManager {
         this.eventQueue.length = 0;
         this.initialized = false;
         this.client = null;
-        this.logger.info(`[OpenClawHooks] Hooks shutdown complete (${queuedCount} queued events dropped)`);
+        frameworkLogger.log('openclaw-hooks', `Hooks shutdown complete (${queuedCount} queued events dropped)`, 'info', {});
     }
     /**
      * Check if hooks are initialized

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

@@ -462,10 +462,10 @@ export class PluginRegistry extends EventEmitter {
                     this.debounceReload(pluginName);
                 }
             });
-            frameworkLogger.log("plugin-registry", "hot-reload-started", "info", { pluginsDir: this.pluginsDir }).catch(() => { });
+            frameworkLogger.log("plugin-registry", "hot-reload-started", "info", { pluginsDir: this.pluginsDir });
         }
         catch (error) {
-            frameworkLogger.log("plugin-registry", "hot-reload-failed", "error", { error: error instanceof Error ? error.message : String(error) }).catch(() => { });
+            frameworkLogger.log("plugin-registry", "hot-reload-failed", "error", { error: error instanceof Error ? error.message : String(error) });
         }
     }
     /**
@@ -479,7 +479,7 @@ export class PluginRegistry extends EventEmitter {
         const timeout = setTimeout(() => {
             this.reloadDebounce.delete(pluginName);
             this.hotReloadPlugin(pluginName).catch((error) => {
-                frameworkLogger.log("plugin-registry", "hot-reload-error", "error", { pluginName, error: error instanceof Error ? error.message : String(error) }).catch(() => { });
+                frameworkLogger.log("plugin-registry", "hot-reload-error", "error", { pluginName, error: error instanceof Error ? error.message : String(error) });
             });
         }, 1000);
         this.reloadDebounce.set(pluginName, timeout);
@@ -506,7 +506,7 @@ export class PluginRegistry extends EventEmitter {
                 await newPlugin.restart();
             }
             this.emitEvent("plugin-reloaded", { name: pluginName, phase: "loaded" });
-            await frameworkLogger.log("plugin-registry", "plugin-hot-reloaded", "info", { name: pluginName }).catch(() => { });
+            await frameworkLogger.log("plugin-registry", "plugin-hot-reloaded", "info", { name: pluginName });
         }
     }
     /**
@@ -529,7 +529,7 @@ export class PluginRegistry extends EventEmitter {
         results.forEach((result, index) => {
             if (result.status === "rejected") {
                 const pluginNames = Array.from(this.plugins.keys());
-                frameworkLogger.log("plugin-registry", "plugin-shutdown-error", "error", { name: pluginNames[index], error: result.reason }).catch(() => { });
+                frameworkLogger.log("plugin-registry", "plugin-shutdown-error", "error", { name: pluginNames[index], error: result.reason });
             }
         });
         this.plugins.clear();

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

@@ -4,14 +4,12 @@
  * Converts architect-tools.ts functions into MCP server tools
  * Provides contextual analysis capabilities via MCP protocol
  */
-declare class XrayArchitectToolsServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private contextAnalysis;
     private codebaseStructure;
     private dependencyAnalysis;
     private architectureAssessment;
-    run(): Promise<void>;
 }
 export default XrayArchitectToolsServer;

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

@@ -4,159 +4,129 @@
  * 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 { 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;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "architect-tools", version: "2.0.1",
-        }, {
-            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", "2.0.1");
+        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",
                         },
                     },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            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}`);
-                }
-            }
-            catch (error) {
-                frameworkLogger.log("mcps/architect-tools", "tool", "error", { tool: name, error: String(error) });
-                throw error;
-            }
-        });
+                    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" });
     }
     // Tool implementations — delegates to real architect-tools library
     async contextAnalysis(args) {
@@ -216,62 +186,9 @@ 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]}`) {
     const server = new XrayArchitectToolsServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
+    server.run("architect-tools").catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
 }
 export default XrayArchitectToolsServer;

package/dist/mcps/auto-format.server.d.ts

@@ -3,10 +3,9 @@
  *
  * Automated code formatting hook with Prettier and framework-specific formatters
  */
-declare class XrayAutoFormatServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayAutoFormatServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private handleAutoFormat;
     private handleFormatCheck;
     private runPrettier;
@@ -14,6 +13,5 @@ declare class XrayAutoFormatServer {
     private runTypeScriptFormat;
     private checkFormatting;
     private generateFormatSummary;
-    run(): Promise<void>;
 }
 export { XrayAutoFormatServer };