0xray 3.0.11 → 3.0.14

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

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

package/dist/integrations/openclaw/index.js

@@ -12,9 +12,8 @@ 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/xray-hooks.js';
+import { OpenClawHooksManager } from './hooks/strray-hooks.js';
 import { mcpClientManager } from '../../mcps/mcp-client.js';
-import { beforeToolHook, afterToolHook } from '../enforcement-gate.js';
 /**
  * Main OpenClaw Integration class
  * Extends BaseIntegration for consistent lifecycle management
@@ -125,12 +124,6 @@ export class OpenClawIntegration extends BaseIntegration {
         this.mcpToolBeforeUnsubscribe = await mcpClientManager.onToolEvent('tool.before', async (event) => {
             const toolEvent = event;
             try {
-                // Run enforcement gate
-                const gateResult = await beforeToolHook(toolEvent.toolName, toolEvent.args);
-                if (gateResult.blocked) {
-                    await this.log('warning', `Enforcement blocked: ${toolEvent.toolName} (${gateResult.violations.length} violations)`);
-                }
-                // Forward to OpenClaw hook manager (existing behavior)
                 await this.hooksManager.onToolBefore({
                     toolName: toolEvent.toolName,
                     toolId: `${toolEvent.serverName}:${toolEvent.toolName}`,
@@ -138,13 +131,6 @@ export class OpenClawIntegration extends BaseIntegration {
                     duration: 0,
                     timestamp: toolEvent.timestamp,
                     agent: toolEvent.serverName,
-                    enforcement: {
-                        allowed: gateResult.allowed,
-                        blocked: gateResult.blocked,
-                        violations: gateResult.violations,
-                        processed: false,
-                        governanceTriggered: false,
-                    },
                 });
             }
             catch (error) {
@@ -155,8 +141,6 @@ export class OpenClawIntegration extends BaseIntegration {
         this.mcpToolAfterUnsubscribe = await mcpClientManager.onToolEvent('tool.after', async (event) => {
             const toolEvent = event;
             try {
-                // Run enforcement after-hook
-                const afterResult = await afterToolHook(toolEvent.toolName, toolEvent.args, toolEvent.result, toolEvent.error || null);
                 const afterEvent = {
                     toolName: toolEvent.toolName,
                     toolId: `${toolEvent.serverName}:${toolEvent.toolName}`,
@@ -169,13 +153,6 @@ export class OpenClawIntegration extends BaseIntegration {
                     afterEvent.result = toolEvent.result;
                 if (toolEvent.error !== undefined)
                     afterEvent.error = toolEvent.error;
-                afterEvent.enforcement = {
-                    allowed: !afterResult.governanceTriggered || true,
-                    blocked: false,
-                    violations: afterResult.violations,
-                    processed: afterResult.processed,
-                    governanceTriggered: afterResult.governanceTriggered,
-                };
                 await this.hooksManager.onToolAfter(afterEvent);
             }
             catch (error) {
@@ -371,5 +348,4 @@ export * from './types.js';
 export * from './config.js';
 export * from './client.js';
 export * from './api-server.js';
-export { OpenClawHooksManager } from './hooks/xray-hooks.js';
-//# sourceMappingURL=index.js.map
+export { OpenClawHooksManager } from './hooks/strray-hooks.js';

package/dist/integrations/openclaw/types.js

@@ -151,4 +151,3 @@ export function isOpenClawEvent(frame) {
 export function isRecoverableError(error) {
     return error.recoverable;
 }
-//# sourceMappingURL=types.js.map

package/dist/integrations/plugins/index.js

@@ -8,4 +8,3 @@
  */
 export { PluginIntegration, PluginType, PluginState, DEFAULT_PLUGIN_CONFIG, parseYamlManifest, validatePluginManifest, satisfiesVersion, } from "./plugin-integration.js";
 export { PluginRegistry, } from "./plugin-registry.js";
-//# sourceMappingURL=index.js.map

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

@@ -604,4 +604,3 @@ export class PluginIntegration extends BaseIntegration {
         return this.manifest?.optionalDependencies || {};
     }
 }
-//# sourceMappingURL=plugin-integration.js.map

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

@@ -46,8 +46,8 @@ export class PluginRegistry extends EventEmitter {
     reloadDebounce = new Map();
     constructor(config = {}) {
         super();
-        this.pluginsDir = config.pluginsDir || ".xray/plugins";
-        this.configPath = config.configPath || ".xray/config/plugin-config.json";
+        this.pluginsDir = config.pluginsDir || ".strray/plugins";
+        this.configPath = config.configPath || ".strray/config/plugin-config.json";
         this.autoStart = config.autoStart ?? true;
         this.enableMetrics = config.enableMetrics ?? true;
         this.enableHotReload = config.enableHotReload ?? false;
@@ -462,10 +462,10 @@ export class PluginRegistry extends EventEmitter {
                     this.debounceReload(pluginName);
                 }
             });
-            frameworkLogger.log("plugin-registry", "hot-reload-started", "info", { pluginsDir: this.pluginsDir });
+            frameworkLogger.log("plugin-registry", "hot-reload-started", "info", { pluginsDir: this.pluginsDir }).catch(() => { });
         }
         catch (error) {
-            frameworkLogger.log("plugin-registry", "hot-reload-failed", "error", { error: error instanceof Error ? error.message : String(error) });
+            frameworkLogger.log("plugin-registry", "hot-reload-failed", "error", { error: error instanceof Error ? error.message : String(error) }).catch(() => { });
         }
     }
     /**
@@ -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) });
+                frameworkLogger.log("plugin-registry", "hot-reload-error", "error", { pluginName, error: error instanceof Error ? error.message : String(error) }).catch(() => { });
             });
         }, 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 });
+            await frameworkLogger.log("plugin-registry", "plugin-hot-reloaded", "info", { name: pluginName }).catch(() => { });
         }
     }
     /**
@@ -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 });
+                frameworkLogger.log("plugin-registry", "plugin-shutdown-error", "error", { name: pluginNames[index], error: result.reason }).catch(() => { });
             }
         });
         this.plugins.clear();
@@ -578,4 +578,3 @@ export class PluginRegistry extends EventEmitter {
         this.emit("event", event);
     }
 }
-//# sourceMappingURL=plugin-registry.js.map

package/dist/mcps/agent-resolver.js

@@ -104,4 +104,3 @@ export async function agentExists(agentName) {
     const registry = await loadAgentRegistry();
     return agentName in registry;
 }
-//# sourceMappingURL=agent-resolver.js.map

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

@@ -4,129 +4,159 @@
  * 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";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
+class XrayArchitectToolsServer {
+    server;
     constructor() {
-        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",
-                        },
-                    },
-                    required: ["projectRoot"],
-                },
+        this.server = new Server({
+            name: "architect-tools", version: "1.22.67",
+        }, {
+            capabilities: {
+                tools: {},
             },
-            {
-                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",
+        });
+        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"],
                         },
                     },
-                    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: "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: "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",
+                    {
+                        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"],
                         },
-                        focusMetrics: {
-                            type: "array",
-                            items: {
-                                type: "string",
-                                enum: [
-                                    "complexity",
-                                    "coupling",
-                                    "cohesion",
-                                    "testability",
-                                    "scalability",
-                                ],
+                    },
+                    {
+                        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",
+                                },
                             },
-                            description: "Specific metrics to focus assessment on",
+                            required: ["projectRoot"],
                         },
                     },
-                    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" });
+                ],
+            };
+        });
+        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;
+            }
+        });
     }
     // Tool implementations — delegates to real architect-tools library
     async contextAnalysis(args) {
@@ -186,10 +216,62 @@ class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
             ],
         };
     }
+    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("architect-tools").catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
+    server.run().catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
 }
 export default XrayArchitectToolsServer;
-//# sourceMappingURL=architect-tools.server.js.map