0xray 3.0.12 → 3.1.0

package/src/mcps/knowledge-skills/log-monitor.server.ts

@@ -6,11 +6,14 @@
  * 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";
 
 interface LogEntry {
   timestamp: string;
@@ -62,7 +65,8 @@ interface LogAnomaly {
   count: number;
 }
 
-class LogMonitorServer extends XrayKnowledgeSkillBase {
+class LogMonitorServer {
+  private server: Server;
   private patternLibrary: LogPattern[] = [
     {
       id: "memory-leak",
@@ -112,193 +116,203 @@ 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();
+  }
+
+  private 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 as Record<string, unknown>;
-        const result = this.analyzeLogs(
-          (params.logs as string[]) || [],
-          (params.options as Record<string, unknown>) || {},
-        );
-        return {
-          content: [
-            { type: "text", text: JSON.stringify(result, null, 2) },
-          ],
-        };
-      },
-      "detect_patterns": async (args) => {
-        const params = args as Record<string, unknown>;
-        const result = this.detectPatterns(
-          (params.logs as string[]) || [],
-          (params.customPatterns as string[]) || [],
-          (params.sensitivity as number) || 80,
-        );
-        return {
-          content: [
-            { type: "text", text: JSON.stringify(result, null, 2) },
-          ],
-        };
-      },
-      "alert_on_issues": async (args) => {
-        const params = args as Record<string, unknown>;
-        const result = this.alertOnIssues(
-          params.analysis as unknown as LogAnalysis,
-          (params.thresholds as Record<string, unknown>) || {},
-        );
-        return {
-          content: [
-            { type: "text", text: JSON.stringify(result, null, 2) },
-          ],
-        };
-      },
-      "correlate_events": async (args) => {
-        const params = args as Record<string, unknown>;
-        const result = this.correlateEvents(
-          (params.logSets as Array<{ source: string; logs: string[] }>) ||
-            [],
-          (params.timeWindow as number) || 60,
-        );
-        return {
-          content: [
-            { type: "text", text: JSON.stringify(result, null, 2) },
-          ],
-        };
-      },
-      "generate_report": async (args) => {
+      ],
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args = {} } = request.params;
+
+      try {
         const params = args as Record<string, unknown>;
-        const result = this.generateReport(
-          params.analysis as unknown as LogAnalysis,
-          (params.format as string) || "json",
-        );
+        switch (name) {
+          case "analyze_logs": {
+            const result = this.analyzeLogs(
+              (params.logs as string[]) || [],
+              (params.options as Record<string, unknown>) || {},
+            );
+            return {
+              content: [
+                { type: "text", text: JSON.stringify(result, null, 2) },
+              ],
+            };
+          }
+          case "detect_patterns": {
+            const result = this.detectPatterns(
+              (params.logs as string[]) || [],
+              (params.customPatterns as string[]) || [],
+              (params.sensitivity as number) || 80,
+            );
+            return {
+              content: [
+                { type: "text", text: JSON.stringify(result, null, 2) },
+              ],
+            };
+          }
+          case "alert_on_issues": {
+            const result = this.alertOnIssues(
+              params.analysis as unknown as LogAnalysis,
+              (params.thresholds as Record<string, unknown>) || {},
+            );
+            return {
+              content: [
+                { type: "text", text: JSON.stringify(result, null, 2) },
+              ],
+            };
+          }
+          case "correlate_events": {
+            const result = this.correlateEvents(
+              (params.logSets as Array<{ source: string; logs: string[] }>) ||
+                [],
+              (params.timeWindow as number) || 60,
+            );
+            return {
+              content: [
+                { type: "text", text: JSON.stringify(result, null, 2) },
+              ],
+            };
+          }
+          case "generate_report": {
+            const result = this.generateReport(
+              params.analysis as unknown as LogAnalysis,
+              (params.format as string) || "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);
-      },
+      }
     });
   }
 
@@ -590,12 +604,16 @@ ${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 };