0xray 4.0.13 → 4.0.14

package/dist/mcps/connection/connection-manager.js

@@ -0,0 +1,79 @@
+import { McpConnection } from './mcp-connection.js';
+import { frameworkLogger } from '../../core/framework-logger.js';
+/**
+ * Connection Manager
+ * Manages MCP connection lifecycle and provides centralized access to connections
+ */
+export class ConnectionManager {
+    connections = new Map();
+    /**
+     * Get or create a connection for a server
+     * @param config - Server configuration
+     * @returns Promise resolving to an MCP connection
+     */
+    async getConnection(config) {
+        const existingConnection = this.connections.get(config.serverName);
+        if (existingConnection && existingConnection.isConnected) {
+            return existingConnection;
+        }
+        // If existing connection is disconnected, remove it
+        if (existingConnection) {
+            await existingConnection.disconnect();
+            this.connections.delete(config.serverName);
+        }
+        // Create new connection
+        const connection = new McpConnection(config);
+        await connection.connect();
+        this.connections.set(config.serverName, connection);
+        return connection;
+    }
+    /**
+     * Disconnect a specific server
+     * @param serverName - Name of the server to disconnect
+     */
+    async disconnect(serverName) {
+        const connection = this.connections.get(serverName);
+        if (connection) {
+            await connection.disconnect();
+            this.connections.delete(serverName);
+        }
+    }
+    /**
+     * Disconnect all managed connections
+     */
+    async disconnectAll() {
+        const disconnectPromises = [];
+        for (const [serverName, connection] of this.connections) {
+            disconnectPromises.push(connection.disconnect().catch((error) => {
+                frameworkLogger.log("connection-manager", "disconnect-error", "error", { serverName, error });
+            }));
+        }
+        await Promise.all(disconnectPromises);
+        this.connections.clear();
+    }
+    /**
+     * Check if a connection exists for a server
+     * @param serverName - Name of the server
+     * @returns True if connection exists and is connected
+     */
+    hasConnection(serverName) {
+        const connection = this.connections.get(serverName);
+        return connection !== undefined && connection.isConnected;
+    }
+    /**
+     * Get all connected server names
+     * @returns Array of server names
+     */
+    getConnectedServers() {
+        return Array.from(this.connections.entries())
+            .filter(([, connection]) => connection.isConnected)
+            .map(([name]) => name);
+    }
+    /**
+     * Get the number of active connections
+     * @returns Number of connections
+     */
+    getConnectionCount() {
+        return this.getConnectedServers().length;
+    }
+}

package/dist/mcps/connection/connection-pool.d.ts

@@ -0,0 +1,64 @@
+import { IMcpConnection, IServerConfig } from '../types/index.js';
+/**
+ * Connection Pool Interface
+ * Defines the contract for connection pool implementations
+ */
+export interface IConnectionPoolExtended {
+    acquire(serverName: string, config: IServerConfig): Promise<IMcpConnection>;
+    release(connection: IMcpConnection): void;
+    clear(): Promise<void>;
+}
+/**
+ * Connection Pool
+ * Manages a pool of reusable MCP connections per server
+ */
+export declare class ConnectionPool implements IConnectionPoolExtended {
+    private pools;
+    private maxPoolSize;
+    private maxIdleTimeMs;
+    constructor(options?: {
+        maxPoolSize?: number;
+        maxIdleTimeMs?: number;
+    });
+    /**
+     * Acquire a connection from the pool or create a new one
+     * @param serverName - Name of the server
+     * @param config - Server configuration (used when creating new connections)
+     * @returns Promise resolving to an MCP connection
+     */
+    acquire(serverName: string, config: IServerConfig): Promise<IMcpConnection>;
+    /**
+     * Release a connection back to the pool
+     * @param connection - The connection to release
+     */
+    release(connection: IMcpConnection): void;
+    /**
+     * Clear all connections in the pool
+     */
+    clear(): Promise<void>;
+    /**
+     * Get pool statistics
+     * @returns Object with pool statistics
+     */
+    getStats(): {
+        totalServers: number;
+        totalConnections: number;
+        activeConnections: number;
+        idleConnections: number;
+    };
+    /**
+     * Get pool statistics for a specific server
+     * @param serverName - Name of the server
+     * @returns Pool statistics or null if server not in pool
+     */
+    getServerStats(serverName: string): {
+        total: number;
+        active: number;
+        idle: number;
+    } | null;
+    /**
+     * Clean up stale (idle for too long) connections from a pool
+     */
+    private cleanupStaleConnections;
+}
+export declare function getConnectionPool(): ConnectionPool;

package/dist/mcps/connection/connection-pool.js

@@ -0,0 +1,164 @@
+import { McpConnection } from './mcp-connection.js';
+import { frameworkLogger } from '../../core/framework-logger.js';
+/**
+ * Connection Pool
+ * Manages a pool of reusable MCP connections per server
+ */
+export class ConnectionPool {
+    pools = new Map();
+    maxPoolSize;
+    maxIdleTimeMs;
+    constructor(options = {}) {
+        this.maxPoolSize = options.maxPoolSize || 5;
+        this.maxIdleTimeMs = options.maxIdleTimeMs || 300000; // 5 minutes default
+    }
+    /**
+     * Acquire a connection from the pool or create a new one
+     * @param serverName - Name of the server
+     * @param config - Server configuration (used when creating new connections)
+     * @returns Promise resolving to an MCP connection
+     */
+    async acquire(serverName, config) {
+        let pool = this.pools.get(serverName);
+        if (!pool) {
+            pool = [];
+            this.pools.set(serverName, pool);
+        }
+        // Clean up stale connections first
+        this.cleanupStaleConnections(pool);
+        // Find available connection
+        const availableIndex = pool.findIndex((p) => !p.inUse && p.connection.isConnected);
+        if (availableIndex !== -1) {
+            const pooled = pool[availableIndex];
+            if (pooled) {
+                pooled.inUse = true;
+                pooled.lastUsed = new Date();
+                return pooled.connection;
+            }
+        }
+        // Create new connection if under limit
+        if (pool.length < this.maxPoolSize) {
+            const connection = new McpConnection(config);
+            await connection.connect();
+            const pooled = {
+                connection,
+                inUse: true,
+                lastUsed: new Date(),
+                createdAt: new Date(),
+            };
+            pool.push(pooled);
+            return connection;
+        }
+        throw new Error(`Connection pool exhausted for ${serverName}. Max size: ${this.maxPoolSize}`);
+    }
+    /**
+     * Release a connection back to the pool
+     * @param connection - The connection to release
+     */
+    release(connection) {
+        for (const pool of this.pools.values()) {
+            const pooled = pool.find((p) => p.connection === connection);
+            if (pooled) {
+                pooled.inUse = false;
+                pooled.lastUsed = new Date();
+                return;
+            }
+        }
+    }
+    /**
+     * Clear all connections in the pool
+     */
+    async clear() {
+        const disconnectPromises = [];
+        for (const pool of this.pools.values()) {
+            for (const pooled of pool) {
+                disconnectPromises.push(pooled.connection.disconnect().catch((error) => {
+                    frameworkLogger.log("connection-pool", "disconnect-error", "error", { error });
+                }));
+            }
+        }
+        await Promise.all(disconnectPromises);
+        this.pools.clear();
+    }
+    /**
+     * Get pool statistics
+     * @returns Object with pool statistics
+     */
+    getStats() {
+        let totalConnections = 0;
+        let activeConnections = 0;
+        let idleConnections = 0;
+        for (const pool of this.pools.values()) {
+            totalConnections += pool.length;
+            for (const pooled of pool) {
+                if (pooled.inUse) {
+                    activeConnections++;
+                }
+                else {
+                    idleConnections++;
+                }
+            }
+        }
+        return {
+            totalServers: this.pools.size,
+            totalConnections,
+            activeConnections,
+            idleConnections,
+        };
+    }
+    /**
+     * Get pool statistics for a specific server
+     * @param serverName - Name of the server
+     * @returns Pool statistics or null if server not in pool
+     */
+    getServerStats(serverName) {
+        const pool = this.pools.get(serverName);
+        if (!pool) {
+            return null;
+        }
+        let active = 0;
+        let idle = 0;
+        for (const pooled of pool) {
+            if (pooled.inUse) {
+                active++;
+            }
+            else {
+                idle++;
+            }
+        }
+        return {
+            total: pool.length,
+            active,
+            idle,
+        };
+    }
+    /**
+     * Clean up stale (idle for too long) connections from a pool
+     */
+    cleanupStaleConnections(pool) {
+        const now = new Date();
+        for (let i = pool.length - 1; i >= 0; i--) {
+            const pooled = pool[i];
+            if (pooled &&
+                !pooled.inUse &&
+                now.getTime() - pooled.lastUsed.getTime() > this.maxIdleTimeMs) {
+                // Disconnect and remove stale connection
+                pooled.connection.disconnect().catch((error) => {
+                    frameworkLogger.log("connection-pool", "stale-disconnect-error", "error", { error });
+                });
+                pool.splice(i, 1);
+            }
+        }
+    }
+}
+// Shared singleton for real MCP transport (production path)
+let sharedConnectionPool = null;
+export function getConnectionPool() {
+    if (!sharedConnectionPool) {
+        sharedConnectionPool = new ConnectionPool({
+            maxPoolSize: 10,
+            maxIdleTimeMs: 5 * 60 * 1000,
+        });
+    }
+    return sharedConnectionPool;
+}

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

@@ -0,0 +1,66 @@
+import { EventEmitter } from 'events';
+import { IMcpConnection, JsonRpcRequest, JsonRpcResponse, IServerConfig } from '../types/index.js';
+/**
+ * MCP Connection
+ * Manages a single connection to an MCP server via spawned process
+ */
+export declare class McpConnection extends EventEmitter implements IMcpConnection {
+    private config;
+    readonly serverName: string;
+    private processSpawner;
+    private process;
+    private _isConnected;
+    private requestId;
+    private pendingRequests;
+    private stdoutBuffer;
+    private readonly timeout;
+    constructor(config: IServerConfig);
+    /**
+     * Check if the connection is active
+     */
+    get isConnected(): boolean;
+    /**
+     * Connect to the MCP server
+     * Spawns the process and sets up event handlers
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the MCP server
+     * Kills the process and cleans up resources
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a JSON-RPC request to the MCP server
+     * @param request - The JSON-RPC request to send
+     * @returns Promise that resolves with the response
+     */
+    sendRequest(request: JsonRpcRequest): Promise<JsonRpcResponse>;
+    /**
+     * Set up event handlers for the spawned process
+     */
+    private setupEventHandlers;
+    /**
+     * Handle stdout data from the process
+     */
+    private handleStdout;
+    /**
+     * Handle a JSON-RPC response
+     */
+    private handleResponse;
+    /**
+     * Handle stderr data from the process
+     */
+    private handleStderr;
+    /**
+     * Handle process errors
+     */
+    private handleError;
+    /**
+     * Handle process close
+     */
+    private handleClose;
+    /**
+     * Clean up resources
+     */
+    private cleanup;
+}

package/dist/mcps/connection/mcp-connection.js

@@ -0,0 +1,233 @@
+import { EventEmitter } from 'events';
+import { frameworkLogger } from '../../core/framework-logger.js';
+import { MCP_PROTOCOL_VERSION, JSONRPC_VERSION, } from '../protocol/protocol-constants.js';
+import { ProcessSpawner } from './process-spawner.js';
+/**
+ * MCP Connection
+ * Manages a single connection to an MCP server via spawned process
+ */
+export class McpConnection extends EventEmitter {
+    config;
+    serverName;
+    processSpawner;
+    process;
+    _isConnected = false;
+    requestId = 0;
+    pendingRequests = new Map();
+    stdoutBuffer = '';
+    timeout;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.serverName = config.serverName;
+        this.processSpawner = new ProcessSpawner();
+        this.timeout = config.timeout || 30000;
+    }
+    /**
+     * Check if the connection is active
+     */
+    get isConnected() {
+        return this._isConnected && this.process !== undefined && !this.process.killed;
+    }
+    /**
+     * Connect to the MCP server
+     * Spawns the process and sets up event handlers
+     */
+    async connect() {
+        if (this._isConnected) {
+            return;
+        }
+        const jobId = `mcp-connect-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        try {
+            frameworkLogger.log('mcp-connection', `Connecting to ${this.serverName}`, 'info', { jobId });
+            const spawnResult = this.processSpawner.spawn(this.config);
+            this.process = spawnResult.process;
+            this.setupEventHandlers();
+            // Send initialize request
+            const initRequest = {
+                jsonrpc: JSONRPC_VERSION,
+                id: ++this.requestId,
+                method: 'initialize',
+                params: {
+                    protocolVersion: MCP_PROTOCOL_VERSION,
+                    capabilities: {},
+                    clientInfo: {
+                        name: 'xray-mcp-client',
+                        version: '1.7.5',
+                    },
+                },
+            };
+            await this.sendRequest(initRequest);
+            this._isConnected = true;
+            frameworkLogger.log('mcp-connection', `Connected to ${this.serverName}`, 'success', { jobId });
+        }
+        catch (error) {
+            frameworkLogger.log('mcp-connection', `Failed to connect to ${this.serverName}: ${error instanceof Error ? error.message : String(error)}`, 'error', { jobId, error });
+            this.cleanup();
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from the MCP server
+     * Kills the process and cleans up resources
+     */
+    async disconnect() {
+        if (!this._isConnected && !this.process) {
+            return;
+        }
+        const jobId = `mcp-disconnect-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        frameworkLogger.log('mcp-connection', `Disconnecting from ${this.serverName}`, 'info', { jobId });
+        // Reject all pending requests
+        Array.from(this.pendingRequests.entries()).forEach(([id, { reject }]) => {
+            reject(new Error('Connection closed'));
+        });
+        this.pendingRequests.clear();
+        this.cleanup();
+        this._isConnected = false;
+        frameworkLogger.log('mcp-connection', `Disconnected from ${this.serverName}`, 'info', { jobId });
+    }
+    /**
+     * Send a JSON-RPC request to the MCP server
+     * @param request - The JSON-RPC request to send
+     * @returns Promise that resolves with the response
+     */
+    async sendRequest(request) {
+        if (!this.process || this.process.killed) {
+            throw new Error('Not connected to MCP server');
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.pendingRequests.delete(request.id);
+                reject(new Error(`Request timeout after ${this.timeout}ms`));
+            }, this.timeout);
+            this.pendingRequests.set(request.id, {
+                resolve: (response) => {
+                    clearTimeout(timeoutId);
+                    resolve(response);
+                },
+                reject: (error) => {
+                    clearTimeout(timeoutId);
+                    reject(error);
+                },
+            });
+            try {
+                if (!this.process || !this.process.stdin) {
+                    throw new Error('Process not available');
+                }
+                this.process.stdin.write(JSON.stringify(request) + '\n');
+            }
+            catch (error) {
+                this.pendingRequests.delete(request.id);
+                clearTimeout(timeoutId);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    /**
+     * Set up event handlers for the spawned process
+     */
+    setupEventHandlers() {
+        if (!this.process) {
+            return;
+        }
+        const proc = this.process;
+        if (proc.stdout) {
+            proc.stdout.on('data', (data) => {
+                this.handleStdout(data.toString());
+            });
+        }
+        if (proc.stderr) {
+            proc.stderr.on('data', (data) => {
+                this.handleStderr(data.toString());
+            });
+        }
+        this.process.on('error', (error) => {
+            this.handleError(error);
+        });
+        this.process.on('close', (code) => {
+            this.handleClose(code);
+        });
+    }
+    /**
+     * Handle stdout data from the process
+     */
+    handleStdout(data) {
+        this.stdoutBuffer += data;
+        // Parse complete JSON-RPC messages (one per line)
+        const lines = this.stdoutBuffer.split('\n');
+        this.stdoutBuffer = lines.pop() || ''; // Keep incomplete line in buffer
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine) {
+                continue;
+            }
+            try {
+                const response = JSON.parse(trimmedLine);
+                this.handleResponse(response);
+            }
+            catch {
+                // Not valid JSON, log and continue
+                frameworkLogger.log('mcp-connection', `Received non-JSON data: ${trimmedLine.substring(0, 100)}`, 'debug');
+            }
+        }
+    }
+    /**
+     * Handle a JSON-RPC response
+     */
+    handleResponse(response) {
+        const pending = this.pendingRequests.get(response.id);
+        if (!pending) {
+            frameworkLogger.log('mcp-connection', `Received response for unknown request ID: ${response.id}`, 'warning');
+            return;
+        }
+        this.pendingRequests.delete(response.id);
+        if (response.error) {
+            pending.reject(new Error(response.error.message || 'MCP server error'));
+        }
+        else {
+            pending.resolve(response);
+        }
+    }
+    /**
+     * Handle stderr data from the process
+     */
+    handleStderr(data) {
+        frameworkLogger.log('mcp-connection', `stderr from ${this.serverName}: ${data.substring(0, 500)}`, 'debug');
+        this.emit('stderr', data);
+    }
+    /**
+     * Handle process errors
+     */
+    handleError(error) {
+        frameworkLogger.log('mcp-connection', `Process error for ${this.serverName}: ${error.message}`, 'error', { error: error.message });
+        // Reject all pending requests
+        Array.from(this.pendingRequests.entries()).forEach(([id, { reject }]) => {
+            reject(new Error(`Process error: ${error.message}`));
+        });
+        this.pendingRequests.clear();
+        this.emit('error', error);
+    }
+    /**
+     * Handle process close
+     */
+    handleClose(code) {
+        frameworkLogger.log('mcp-connection', `Process for ${this.serverName} closed with code ${code}`, 'info');
+        // Reject all pending requests
+        Array.from(this.pendingRequests.entries()).forEach(([id, { reject }]) => {
+            reject(new Error(`Process closed with code ${code}`));
+        });
+        this.pendingRequests.clear();
+        this._isConnected = false;
+        this.emit('close', code);
+    }
+    /**
+     * Clean up resources
+     */
+    cleanup() {
+        if (this.process && !this.process.killed) {
+            this.process.kill();
+        }
+        this.process = undefined;
+        this.stdoutBuffer = '';
+    }
+}

package/dist/mcps/connection/process-spawner.d.ts

@@ -0,0 +1,24 @@
+import { ChildProcess } from 'child_process';
+import { IServerConfig } from '../types/index.js';
+/**
+ * Spawn Result
+ * Contains the spawned process and its stdio streams
+ */
+export interface SpawnResult {
+    process: ChildProcess;
+    stdout: NodeJS.ReadableStream;
+    stdin: NodeJS.WritableStream;
+    stderr: NodeJS.ReadableStream;
+}
+/**
+ * Process Spawner
+ * Handles spawning of MCP server processes
+ */
+export declare class ProcessSpawner {
+    /**
+     * Spawn a new process with the given configuration
+     * @param config - Server configuration containing command, args, env, and basePath
+     * @returns SpawnResult with process and stdio streams
+     */
+    spawn(config: IServerConfig): SpawnResult;
+}

package/dist/mcps/connection/process-spawner.js

@@ -0,0 +1,34 @@
+import { spawn } from 'child_process';
+/**
+ * Process Spawner
+ * Handles spawning of MCP server processes
+ */
+export class ProcessSpawner {
+    /**
+     * Spawn a new process with the given configuration
+     * @param config - Server configuration containing command, args, env, and basePath
+     * @returns SpawnResult with process and stdio streams
+     */
+    spawn(config) {
+        const ALLOWED_ENV_KEYS = new Set([
+            'PATH', 'HOME', 'NODE_PATH', 'TMPDIR', 'TEMP', 'TMP',
+            'LANG', 'LC_ALL',
+        ]);
+        const safeEnv = {};
+        for (const key of ALLOWED_ENV_KEYS) {
+            if (process.env[key])
+                safeEnv[key] = process.env[key];
+        }
+        const proc = spawn(config.command, config.args, {
+            env: { ...safeEnv, ...config.env },
+            cwd: config.basePath,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return {
+            process: proc,
+            stdout: proc.stdout,
+            stdin: proc.stdin,
+            stderr: proc.stderr,
+        };
+    }
+}

package/dist/mcps/enforcer-tools.server.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 0xRay Enforcer Tools MCP Server
+ *
+ * Converts enforcer-tools.ts functions into MCP server tools
+ * Provides rule enforcement and validation capabilities via MCP protocol
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayEnforcerToolsServer extends XrayKnowledgeSkillBase {
+    constructor();
+    setupToolHandlers(): void;
+    private ruleValidation;
+    private codexEnforcement;
+    private contextAnalysisValidation;
+    private qualityGateCheck;
+    private getEnforcementStatus;
+    private runPreCommitValidation;
+    private getCodexTermCount;
+    private simulateRuleValidation;
+    private simulateCodexValidation;
+    private simulateContextValidation;
+    private performQualityGateCheck;
+    private simulateEnforcementStatus;
+    private performPreCommitValidation;
+    private securityScan;
+}
+export default XrayEnforcerToolsServer;