0xray 2.1.2 → 2.1.3

package/dist/mcps/knowledge-skills/log-monitor.server.d.ts

@@ -5,11 +5,10 @@
  * Monitors application logs for errors, anomalies, security threats,
  * and performance issues in real-time.
  */
-declare class LogMonitorServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class LogMonitorServer extends XrayKnowledgeSkillBase {
     private patternLibrary;
     constructor();
-    private setupToolHandlers;
     private analyzeLogs;
     private detectPatterns;
     private alertOnIssues;
@@ -19,6 +18,5 @@ declare class LogMonitorServer {
     private detectPatternsInLogs;
     private detectAnomalies;
     private generateRecommendations;
-    run(): Promise<void>;
 }
 export { LogMonitorServer };

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

@@ -5,13 +5,11 @@
  * 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";
-class LogMonitorServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+class LogMonitorServer extends XrayKnowledgeSkillBase {
     patternLibrary = [
         {
             id: "memory-leak",
@@ -60,180 +58,167 @@ class LogMonitorServer {
         },
     ];
     constructor() {
-        this.server = new Server({ name: "log-monitor", version: "2.0.1" }, { 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",
-                                    },
+        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",
                                 },
                             },
                         },
-                        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",
-                            },
                         },
-                        required: ["logSets"],
+                        timeWindow: {
+                            type: "number",
+                            description: "Time window in seconds",
+                        },
                     },
+                    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.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args = {} } = request.params;
-            try {
+            },
+        ];
+        this.handlers = {
+            "analyze_logs": async (args) => {
                 const params = args;
-                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) {
+                const result = this.analyzeLogs(params.logs || [], params.options || {});
                 return {
-                    content: [{ type: "text", text: `Error: ${error}` }],
-                    isError: true,
+                    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) => {
+                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");
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(result, null, 2) },
+                    ],
+                };
+            },
+        };
+        this.setupToolHandlers();
     }
     analyzeLogs(logs, options) {
         const entries = logs.map(this.parseLogEntry);
@@ -438,14 +423,10 @@ ${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();
+    server.run("log-monitor").catch((err) => { frameworkLogger.log("log-monitor", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 export { LogMonitorServer };

package/dist/mcps/knowledge-skills/mobile-development.server.d.ts

@@ -4,16 +4,14 @@
  * Knowledge skill for mobile app development including iOS, Android,
  * React Native, Flutter, and mobile performance optimization
  */
-declare class XrayMobileDevelopmentServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayMobileDevelopmentServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private generateIOSBlueprint;
     private generateAndroidBlueprint;
     private generateReactNativeBlueprint;
     private generateFlutterBlueprint;
     private analyzeMobilePerformance;
     private generateAppStoreMetadata;
-    start(): Promise<void>;
 }
 export { XrayMobileDevelopmentServer };