0xray 4.0.12 → 4.0.13

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

@@ -1,79 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,233 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,26 +0,0 @@
-/**
- * 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;