0xray 4.0.12 → 4.0.13

package/dist/mcps/lint.server.d.ts

@@ -1,15 +0,0 @@
-/**
- * 0xRay Lint MCP Server
- *
- * Comprehensive ESLint validation and automated code quality checking
- */
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-declare class XrayLintServer extends XrayKnowledgeSkillBase {
-    constructor();
-    private handleLint;
-    private handleLintCheck;
-    private runEslint;
-    private checkLintRules;
-    private generateLintSummary;
-}
-export { XrayLintServer };

package/dist/mcps/lint.server.js

@@ -1,340 +0,0 @@
-/**
- * 0xRay Lint MCP Server
- *
- * Comprehensive ESLint validation and automated code quality checking
- */
-import { execFileSync } from "child_process";
-import fs from "fs";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-class XrayLintServer extends XrayKnowledgeSkillBase {
-    constructor() {
-        super("lint", "3.1.0");
-        this.tools = [
-            {
-                name: "lint",
-                description: "Comprehensive ESLint validation and automated code quality checking",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        files: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "Specific files to lint (optional - lints all if empty)",
-                        },
-                        fix: {
-                            type: "boolean",
-                            default: false,
-                            description: "Automatically fix linting issues where possible",
-                        },
-                        strict: {
-                            type: "boolean",
-                            default: false,
-                            description: "Use strict linting rules",
-                        },
-                    },
-                },
-            },
-            {
-                name: "lint-check",
-                description: "Check code quality without making changes",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        files: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "Files to check",
-                        },
-                        rules: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "Specific ESLint rules to check",
-                        },
-                    },
-                },
-            },
-        ];
-        this.handlers = {
-            "lint": async (args) => this.handleLint(args),
-            "lint-check": async (args) => this.handleLintCheck(args),
-        };
-        this.setupToolHandlers();
-        void frameworkLogger.log("lint.server", "-xray-lint-mcp-server-initialized-", "info", { message: "0xRay Lint MCP Server initialized" });
-    }
-    async handleLint(args) {
-        const files = args.files || [];
-        const fix = args.fix || false;
-        const strict = args.strict || false;
-        await frameworkLogger.log("lint.server", "-mcp-running-lint-files-files-length-fix-strict-", "info", { message: "🔍 MCP: Running lint:", files: files.length, fix, strict });
-        const lintResults = {
-            success: true,
-            issues: {
-                errors: 0,
-                warnings: 0,
-                fixed: 0,
-            },
-            files: [],
-            summary: "",
-            details: [],
-        };
-        try {
-            const eslintResults = await this.runEslint(files, fix, strict);
-            lintResults.issues = eslintResults.issues;
-            lintResults.files = eslintResults.files;
-            lintResults.details = eslintResults.details;
-            lintResults.success = eslintResults.success;
-            // Generate summary
-            lintResults.summary = this.generateLintSummary(lintResults);
-        }
-        catch (error) {
-            frameworkLogger.log("mcps/lint", "lint", "error", { error: String(error) });
-            lintResults.success = false;
-            lintResults.details.push(`Lint failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        const response = `🔍 0xRay Lint Results
-
-${lintResults.summary}
-
-**Files Checked:** ${lintResults.files.length}
-**Errors:** ${lintResults.issues.errors}
-**Warnings:** ${lintResults.issues.warnings}
-**Auto-fixed:** ${lintResults.issues.fixed}
-
-**Issues Found:**
-${lintResults.details.length > 0 ? lintResults.details.map((d) => `• ${d}`).join("\n") : "None"}
-
-**Status:** ${lintResults.success ? "✅ LINTING PASSED" : "❌ LINTING ISSUES DETECTED"}`;
-        return {
-            content: [{ type: "text", text: response }],
-        };
-    }
-    async handleLintCheck(args) {
-        const files = args.files || [];
-        const rules = args.rules || [];
-        await frameworkLogger.log("lint.server", "-mcp-checking-lint-for-files-files-length", "info", { message: "🔍 MCP: Checking lint for files:", fileCount: files.length });
-        try {
-            const checkResults = await this.checkLintRules(files, rules);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `🔍 Lint Check Results
-
-**Files Checked:** ${files.length}
-**Rules Validated:** ${rules.length > 0 ? rules.length : "All"}
-**Compliant:** ${checkResults.compliant}
-**Violations:** ${checkResults.violations}
-
-**Details:**
-${checkResults.details.map((d) => `• ${d}`).join("\n")}
-
-**Status:** ${checkResults.violations === 0 ? "✅ COMPLIANT" : "❌ VIOLATIONS DETECTED"}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `❌ Lint check failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async runEslint(files, fix, strict) {
-        const results = {
-            success: true,
-            issues: { errors: 0, warnings: 0, fixed: 0 },
-            files: [],
-            details: [],
-        };
-        try {
-            if (!fs.existsSync("package.json")) {
-                results.success = false;
-                results.details.push("No package.json found - cannot run ESLint");
-                return results;
-            }
-            // Check for ESLint configuration (including ESLint 9+ flat config)
-            const hasEslintConfig = fs.existsSync(".eslintrc.js") ||
-                fs.existsSync(".eslintrc.json") ||
-                fs.existsSync(".eslintrc.yml") ||
-                fs.existsSync(".eslintrc.yaml") ||
-                fs.existsSync("eslint.config.js") ||
-                fs.existsSync("eslint.config.mjs") ||
-                (fs.existsSync("package.json") &&
-                    JSON.parse(fs.readFileSync("package.json", "utf8")).eslintConfig);
-            if (!hasEslintConfig) {
-                results.success = false;
-                results.details.push("No ESLint configuration found");
-                return results;
-            }
-            const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
-            const scripts = packageJson.scripts || {};
-            // Determine command and arguments (using args array to prevent command injection)
-            let command;
-            let args;
-            const fileArgs = files.length > 0 ? files : ["."];
-            if (fix && scripts["lint:fix"]) {
-                command = "npm";
-                args = ["run", "lint:fix", "--", ...fileArgs];
-            }
-            else if (!fix && scripts.lint) {
-                command = "npm";
-                args = ["run", "lint", "--", ...fileArgs];
-            }
-            else {
-                command = "npx";
-                args = ["eslint", ...fileArgs, "--format", "json"];
-            }
-            if (strict) {
-                args.push("--max-warnings", "0");
-            }
-            const execOptions = {
-                encoding: "utf8",
-                cwd: process.cwd(),
-                stdio: "pipe",
-                timeout: 30000,
-            };
-            try {
-                const output = execFileSync(command, args, execOptions);
-                // Parse ESLint output
-                results.files = files.length > 0 ? files : ["All files"];
-                // Parse ESLint JSON output for accurate counts
-                let errorCount = 0;
-                let warningCount = 0;
-                try {
-                    const jsonResults = JSON.parse(output);
-                    if (Array.isArray(jsonResults)) {
-                        for (const fileResult of jsonResults) {
-                            errorCount += fileResult.errorCount || 0;
-                            warningCount += fileResult.warningCount || 0;
-                        }
-                    }
-                }
-                catch {
-                    // JSON parse failed — fall back to regex-based parsing
-                    const errorMatches = output.match(/(\d+)\s+errors?/);
-                    const warningMatches = output.match(/(\d+)\s+warnings?/);
-                    if (errorMatches?.[1])
-                        errorCount = parseInt(errorMatches[1]);
-                    if (warningMatches?.[1])
-                        warningCount = parseInt(warningMatches[1]);
-                }
-                results.issues.errors = errorCount;
-                results.issues.warnings = warningCount;
-                results.issues.fixed = fix ? Math.max(0, errorCount + warningCount) : 0;
-                if (results.issues.errors > 0) {
-                    results.success = false;
-                    results.details.push(`${results.issues.errors} ESLint errors found`);
-                }
-                if (results.issues.warnings > 0 && strict) {
-                    results.success = false;
-                    results.details.push(`${results.issues.warnings} ESLint warnings found (strict mode)`);
-                }
-                if (results.issues.errors === 0 && results.issues.warnings === 0) {
-                    results.details.push("No ESLint issues found");
-                }
-            }
-            catch (error) {
-                const errorOutput = error instanceof Error
-                    ? (error.stdout?.toString() || error.stderr?.toString() || error.message)
-                    : String(error);
-                results.success = false;
-                // Try JSON parsing of error output first for accurate counts
-                let parsedJson = false;
-                try {
-                    const jsonResults = JSON.parse(errorOutput);
-                    if (Array.isArray(jsonResults)) {
-                        for (const fileResult of jsonResults) {
-                            results.issues.errors += fileResult.errorCount || 0;
-                            results.issues.warnings += fileResult.warningCount || 0;
-                        }
-                        parsedJson = true;
-                    }
-                }
-                catch {
-                    // Fall back to regex
-                }
-                if (!parsedJson) {
-                    const errorMatches = errorOutput.match(/(\d+)\s+errors?/);
-                    const warningMatches = errorOutput.match(/(\d+)\s+warnings?/);
-                    if (errorMatches)
-                        results.issues.errors = parseInt(errorMatches[1]);
-                    if (warningMatches)
-                        results.issues.warnings = parseInt(warningMatches[1]);
-                }
-                results.details.push(`ESLint found ${results.issues.errors} errors, ${results.issues.warnings} warnings`);
-            }
-        }
-        catch (error) {
-            results.success = false;
-            results.details.push(`ESLint setup error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return results;
-    }
-    async checkLintRules(files, rules) {
-        const results = {
-            compliant: 0,
-            violations: 0,
-            details: [],
-        };
-        try {
-            if (rules.length === 0) {
-                // General compliance check
-                const generalResults = await this.runEslint(files, false, false);
-                results.violations =
-                    generalResults.issues.errors + generalResults.issues.warnings;
-                results.compliant = generalResults.success
-                    ? files.length
-                    : Math.max(0, files.length - results.violations);
-                results.details.push(`General compliance: ${results.violations === 0 ? "PASS" : "FAIL"}`);
-            }
-            else {
-                // Check specific rules (using args array to prevent command injection)
-                const fileArgs = files.length > 0 ? files : ["."];
-                for (const rule of rules) {
-                    try {
-                        execFileSync("npx", ["eslint", ...fileArgs, "--rule", `${rule}:error`, "--format", "json"], {
-                            encoding: "utf8",
-                            cwd: process.cwd(),
-                            stdio: "pipe",
-                            timeout: 30000,
-                        });
-                        results.compliant++;
-                        results.details.push(`Rule ${rule}: PASS`);
-                    }
-                    catch (error) {
-                        results.violations++;
-                        const errorOutput = error instanceof Error
-                            ? (error.stdout?.toString() || error.message)
-                            : String(error);
-                        results.details.push(`Rule ${rule}: FAIL - ${errorOutput.substring(0, 200)}`);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            results.details.push(`Lint rule check error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return results;
-    }
-    generateLintSummary(results) {
-        const totalIssues = results.issues.errors + results.issues.warnings;
-        const status = results.success ? "PASSED" : "ISSUES DETECTED";
-        return `**Linting Summary:** ${status}
-- Files: ${results.files.length}
-- Errors: ${results.issues.errors}
-- Warnings: ${results.issues.warnings}
-- Fixed: ${results.issues.fixed}`;
-    }
-}
-// Start the server if run directly
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new XrayLintServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/lint", "run", "error", { error: String(error) }));
-}
-export { XrayLintServer };

package/dist/mcps/mcp-client.d.ts

@@ -1,157 +0,0 @@
-/**
- * MCP Client Layer
- *
- * Enables framework components to call MCP servers programmatically.
- * Refactored as a lean facade using extracted modules (Phases 1-5).
- *
- * Architecture:
- * - ToolRegistry: Manages tool registration and lookup
- * - ToolDiscovery: Discovers tools from MCP servers
- * - ToolExecutor: Executes tools via JSON-RPC
- * - ToolCache: Caches discovered tools
- * - SimulationEngine: Provides fallback simulations
- */
-import { EventEmitter } from 'events';
-import { MCPClientConfig, MCPTool, MCPToolResult } from './types/index.js';
-interface RetryConfig {
-    maxRetries: number;
-    initialDelayMs: number;
-    maxDelayMs: number;
-    backoffMultiplier: number;
-}
-/**
- * Tool event types for hooks
- */
-export interface ToolBeforeEvent {
-    toolName: string;
-    serverName: string;
-    args: unknown;
-    timestamp: number;
-}
-export interface ToolAfterEvent extends ToolBeforeEvent {
-    result?: MCPToolResult;
-    error?: string;
-    duration: number;
-    success: boolean;
-}
-/**
- * MCP Client
- *
- * Facade that orchestrates tool discovery, caching, execution, and simulation.
- */
-export declare class MCPClient extends EventEmitter {
-    private config;
-    private toolRegistry;
-    private toolDiscovery;
-    private toolExecutor;
-    private toolCache;
-    private simulationEngine;
-    private retryConfig;
-    constructor(config: MCPClientConfig, retryConfig?: Partial<RetryConfig>);
-    /**
-     * Execute with exponential backoff retry
-     */
-    private executeWithRetry;
-    /**
-     * Execute a tool using the real MCP transport (ConnectionPool + ToolExecutor).
-     * This is the primary production path.
-     */
-    private executeRealTool;
-    /**
-     * Pure MCP mode — simulation and generic fallbacks are disabled.
-     */
-    private get isPureMcpMode();
-    /**
-     * Register default simulation implementations
-     */
-    private registerDefaultSimulations;
-    /**
-     * Initialize MCP client by discovering and caching tools
-     */
-    initialize(): Promise<void>;
-    /**
-     * Discover available tools for this server
-     */
-    private discoverTools;
-    /**
-     * Get static tool definitions for a server
-     */
-    private getStaticTools;
-    /**
-     * Call a specific MCP server tool
-     */
-    callTool(toolName: string, args?: unknown): Promise<MCPToolResult>;
-    /**
-     * Get list of available tools
-     */
-    getAvailableTools(): MCPTool[];
-    /**
-     * Check if a tool is available
-     */
-    hasTool(toolName: string): boolean;
-    /**
-     * Get tool by name
-     */
-    getTool(toolName: string): MCPTool | undefined;
-    /**
-     * Subscribe to tool.before events
-     */
-    onToolBefore(callback: (event: ToolBeforeEvent) => void): void;
-    /**
-     * Subscribe to tool.after events
-     */
-    onToolAfter(callback: (event: ToolAfterEvent) => void): void;
-    /**
-     * Unsubscribe from tool.before events
-     */
-    offToolBefore(callback: (event: ToolBeforeEvent) => void): void;
-    /**
-     * Unsubscribe from tool.after events
-     */
-    offToolAfter(callback: (event: ToolAfterEvent) => void): void;
-}
-/**
- * MCP Client Manager
- *
- * Manages MCP client instances and provides unified interface
- * for framework components to access MCP server capabilities.
- */
-export declare class MCPClientManager {
-    private static instance;
-    private clients;
-    private constructor();
-    static getInstance(): MCPClientManager;
-    /**
-     * Get or create MCP client for a server
-     */
-    getClient(serverName: string): Promise<MCPClient>;
-    /**
-     * Get the event emitter for a specific client
-     * Use this to subscribe to tool.before/tool.after events
-     */
-    getClientEventEmitter(serverName: string): MCPClient | null;
-    /**
-     * Subscribe to tool events across all clients
-     * Note: This creates a subscription for each client - manage subscriptions carefully
-     * @returns Unsubscribe function to call to remove all event listeners
-     */
-    onToolEvent(eventType: 'tool.before' | 'tool.after', callback: (event: ToolBeforeEvent | ToolAfterEvent) => void): Promise<() => void>;
-    /**
-     * Create client configuration for a server
-     */
-    createClientConfig(serverName: string): MCPClientConfig;
-    /**
-     * Call MCP server tool
-     */
-    callServerTool(serverName: string, toolName: string, args?: unknown): Promise<MCPToolResult>;
-    /**
-     * Get all available MCP server tools
-     */
-    getAllAvailableTools(): Promise<Record<string, MCPTool[]>>;
-    /**
-     * Clear all cached clients
-     */
-    clearClients(): void;
-}
-export declare const mcpClientManager: MCPClientManager;
-export {};