0xray 3.0.12 → 3.1.0

package/dist/mcps/knowledge-skills/log-monitor.server.js

@@ -5,12 +5,13 @@
  * Monitors application logs for errors, anomalies, security threats,
  * and performance issues in real-time.
  */
+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 * as path from "path";
 import { fileURLToPath } from "url";
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { pluginRegistry } from "../../nucleus/plugin-registry.js";
-class LogMonitorServer extends XrayKnowledgeSkillBase {
+class LogMonitorServer {
+    server;
     patternLibrary = [
         {
             id: "memory-leak",
@@ -59,175 +60,179 @@ class LogMonitorServer extends XrayKnowledgeSkillBase {
         },
     ];
     constructor() {
-        super("log-monitor", "2.0.1");
-        this.tools = [
-            {
-                name: "analyze_logs",
-                description: "Analyze log entries to identify patterns, errors, and anomalies",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        logs: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "Log entries to analyze",
-                        },
-                        options: {
-                            type: "object",
-                            properties: {
-                                detectPatterns: { type: "boolean", default: true },
-                                findAnomalies: { type: "boolean", default: true },
-                                timeRange: {
-                                    type: "string",
-                                    description: "Time range to analyze",
+        this.server = new Server({ name: "log-monitor", version: "1.22.67" }, { capabilities: { tools: {} } });
+        this.setupToolHandlers();
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: "analyze_logs",
+                    description: "Analyze log entries to identify patterns, errors, and anomalies",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            logs: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Log entries to analyze",
+                            },
+                            options: {
+                                type: "object",
+                                properties: {
+                                    detectPatterns: { type: "boolean", default: true },
+                                    findAnomalies: { type: "boolean", default: true },
+                                    timeRange: {
+                                        type: "string",
+                                        description: "Time range to analyze",
+                                    },
                                 },
                             },
                         },
+                        required: ["logs"],
                     },
-                    required: ["logs"],
                 },
-            },
-            {
-                name: "detect_patterns",
-                description: "Detect specific patterns in logs using regex or predefined patterns",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        logs: { type: "array", items: { type: "string" } },
-                        customPatterns: { type: "array", items: { type: "string" } },
-                        sensitivity: {
-                            type: "number",
-                            minimum: 0,
-                            maximum: 100,
-                            default: 80,
+                {
+                    name: "detect_patterns",
+                    description: "Detect specific patterns in logs using regex or predefined patterns",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            logs: { type: "array", items: { type: "string" } },
+                            customPatterns: { type: "array", items: { type: "string" } },
+                            sensitivity: {
+                                type: "number",
+                                minimum: 0,
+                                maximum: 100,
+                                default: 80,
+                            },
                         },
+                        required: ["logs"],
                     },
-                    required: ["logs"],
                 },
-            },
-            {
-                name: "alert_on_issues",
-                description: "Generate alerts based on log analysis thresholds",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        analysis: {
-                            type: "object",
-                            description: "Results from analyze_logs",
-                        },
-                        thresholds: {
-                            type: "object",
-                            properties: {
-                                errorRate: { type: "number" },
-                                warnRate: { type: "number" },
-                                criticalPatterns: {
-                                    type: "array",
-                                    items: { type: "string" },
+                {
+                    name: "alert_on_issues",
+                    description: "Generate alerts based on log analysis thresholds",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            analysis: {
+                                type: "object",
+                                description: "Results from analyze_logs",
+                            },
+                            thresholds: {
+                                type: "object",
+                                properties: {
+                                    errorRate: { type: "number" },
+                                    warnRate: { type: "number" },
+                                    criticalPatterns: {
+                                        type: "array",
+                                        items: { type: "string" },
+                                    },
                                 },
                             },
                         },
+                        required: ["analysis"],
                     },
-                    required: ["analysis"],
                 },
-            },
-            {
-                name: "correlate_events",
-                description: "Correlate log entries across multiple sources to find related events",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        logSets: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    source: { type: "string" },
-                                    logs: { type: "array", items: { type: "string" } },
+                {
+                    name: "correlate_events",
+                    description: "Correlate log entries across multiple sources to find related events",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            logSets: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    properties: {
+                                        source: { type: "string" },
+                                        logs: { type: "array", items: { type: "string" } },
+                                    },
                                 },
                             },
+                            timeWindow: {
+                                type: "number",
+                                description: "Time window in seconds",
+                            },
                         },
-                        timeWindow: {
-                            type: "number",
-                            description: "Time window in seconds",
-                        },
+                        required: ["logSets"],
                     },
-                    required: ["logSets"],
                 },
-            },
-            {
-                name: "generate_report",
-                description: "Generate a comprehensive log analysis report",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        analysis: { type: "object" },
-                        format: {
-                            type: "string",
-                            enum: ["json", "markdown", "html"],
-                            default: "json",
+                {
+                    name: "generate_report",
+                    description: "Generate a comprehensive log analysis report",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            analysis: { type: "object" },
+                            format: {
+                                type: "string",
+                                enum: ["json", "markdown", "html"],
+                                default: "json",
+                            },
                         },
+                        required: ["analysis"],
                     },
-                    required: ["analysis"],
                 },
-            },
-        ];
-        this.handlers = {
-            "analyze_logs": async (args) => {
-                const params = args;
-                const result = this.analyzeLogs(params.logs || [], params.options || {});
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(result, null, 2) },
-                    ],
-                };
-            },
-            "detect_patterns": async (args) => {
-                const params = args;
-                const result = this.detectPatterns(params.logs || [], params.customPatterns || [], params.sensitivity || 80);
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(result, null, 2) },
-                    ],
-                };
-            },
-            "alert_on_issues": async (args) => {
+            ],
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args = {} } = request.params;
+            try {
                 const params = args;
-                const result = this.alertOnIssues(params.analysis, params.thresholds || {});
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(result, null, 2) },
-                    ],
-                };
-            },
-            "correlate_events": async (args) => {
-                const params = args;
-                const result = this.correlateEvents(params.logSets ||
-                    [], params.timeWindow || 60);
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(result, null, 2) },
-                    ],
-                };
-            },
-            "generate_report": async (args) => {
-                const params = args;
-                const result = this.generateReport(params.analysis, params.format || "json");
+                switch (name) {
+                    case "analyze_logs": {
+                        const result = this.analyzeLogs(params.logs || [], params.options || {});
+                        return {
+                            content: [
+                                { type: "text", text: JSON.stringify(result, null, 2) },
+                            ],
+                        };
+                    }
+                    case "detect_patterns": {
+                        const result = this.detectPatterns(params.logs || [], params.customPatterns || [], params.sensitivity || 80);
+                        return {
+                            content: [
+                                { type: "text", text: JSON.stringify(result, null, 2) },
+                            ],
+                        };
+                    }
+                    case "alert_on_issues": {
+                        const result = this.alertOnIssues(params.analysis, params.thresholds || {});
+                        return {
+                            content: [
+                                { type: "text", text: JSON.stringify(result, null, 2) },
+                            ],
+                        };
+                    }
+                    case "correlate_events": {
+                        const result = this.correlateEvents(params.logSets ||
+                            [], params.timeWindow || 60);
+                        return {
+                            content: [
+                                { type: "text", text: JSON.stringify(result, null, 2) },
+                            ],
+                        };
+                    }
+                    case "generate_report": {
+                        const result = this.generateReport(params.analysis, params.format || "json");
+                        return {
+                            content: [
+                                { type: "text", text: JSON.stringify(result, null, 2) },
+                            ],
+                        };
+                    }
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
                 return {
-                    content: [
-                        { type: "text", text: JSON.stringify(result, null, 2) },
-                    ],
+                    content: [{ type: "text", text: `Error: ${error}` }],
+                    isError: true,
                 };
-            },
-        };
-        this.setupToolHandlers();
-        pluginRegistry.registerToolPlugin({
-            name: "log-monitor",
-            callTool: async (toolName, args) => {
-                const handler = this.handlers[toolName];
-                if (!handler)
-                    throw new Error(`Unknown tool: ${toolName}`);
-                return handler(args);
-            },
+            }
         });
     }
     analyzeLogs(logs, options) {
@@ -433,11 +438,14 @@ ${analysis.recommendations.map((r) => `- ${r}`).join("\n")}
         }
         return recs;
     }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+    }
 }
 const entryPoint = path.resolve(process.argv[1] ?? "");
 if (entryPoint && fileURLToPath(import.meta.url) === entryPoint) {
     const server = new LogMonitorServer();
-    server.run("log-monitor").catch((err) => { frameworkLogger.log("log-monitor", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
+    server.run();
 }
 export { LogMonitorServer };
-//# sourceMappingURL=log-monitor.server.js.map