0xray 4.0.12 → 4.0.13

package/dist/mcps/config/plugin-server-registry.js

@@ -1,222 +0,0 @@
-/**
- * Server Configuration Registry - Plugin Extension
- *
- * Extends ServerConfigRegistry with plugin support for Phase 2.
- * Enables automatic MCP server registration from plugins.
- *
- */
-import { ServerConfigRegistry, defaultServerRegistry } from "./server-config-registry.js";
-import { PluginType } from "../../integrations/plugins/plugin-integration.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-/**
- * ServerConfigRegistry with plugin support
- */
-export class PluginServerConfigRegistry {
-    registry;
-    registeredPluginServers = new Map();
-    pluginRegistryRef;
-    constructor(registry) {
-        // If no registry provided, use default
-        if (registry) {
-            this.registry = registry;
-        }
-        else {
-            // Create new registry with default configs copied
-            this.registry = new ServerConfigRegistry();
-            const defaultConfigs = defaultServerRegistry.getAll();
-            for (const config of defaultConfigs) {
-                this.registry.register(config);
-            }
-        }
-    }
-    /**
-     * Set the plugin registry reference for dynamic updates
-     */
-    setPluginRegistry(registry) {
-        this.pluginRegistryRef = registry;
-    }
-    /**
-     * Get the plugin registry reference
-     */
-    getPluginRegistry() {
-        return this.pluginRegistryRef;
-    }
-    /**
-     * Register a plugin's MCP server configuration
-     */
-    registerPluginServer(plugin, options = {}) {
-        const config = plugin.getMcpServerConfig();
-        if (!config) {
-            frameworkLogger.log("plugin-server-registry", "no-mcp-config", "warning", { plugin: plugin.name, reason: "Not an MCP server type" });
-            return false;
-        }
-        const pluginConfig = {
-            serverName: config.serverName,
-            command: config.command,
-            args: config.args ?? [],
-            timeout: config.timeout ?? 30000,
-            ...(config.env ? { env: config.env } : {}),
-            pluginName: plugin.name,
-            pluginVersion: plugin.version,
-            capabilities: plugin.getCapabilities() ?? [],
-        };
-        // Check for overwrite
-        const existing = this.registry.get(pluginConfig.serverName);
-        if (existing && !options.overwrite) {
-            frameworkLogger.log("plugin-server-registry", "server-exists", "warning", { serverName: pluginConfig.serverName, plugin: plugin.name });
-            return false;
-        }
-        this.registry.register(pluginConfig);
-        this.registeredPluginServers.set(pluginConfig.serverName, pluginConfig);
-        frameworkLogger.log("plugin-server-registry", "server-registered", "info", {
-            serverName: pluginConfig.serverName,
-            plugin: pluginConfig.pluginName,
-            version: pluginConfig.pluginVersion
-        });
-        return true;
-    }
-    /**
-     * Register all MCP server plugins from a plugin registry
-     */
-    registerAllPluginServers(pluginRegistry, options = {}) {
-        const plugins = pluginRegistry.getPluginsByType(PluginType.MCP_SERVER);
-        let registered = 0;
-        for (const plugin of plugins) {
-            if (this.registerPluginServer(plugin, options)) {
-                registered++;
-            }
-        }
-        frameworkLogger.log("plugin-server-registry", "all-servers-registered", "info", { count: registered, total: plugins.length });
-        return registered;
-    }
-    /**
-     * Get a server configuration by name
-     */
-    get(serverName) {
-        return this.registry.get(serverName);
-    }
-    /**
-     * Check if a server configuration exists
-     */
-    has(serverName) {
-        return this.registry.has(serverName);
-    }
-    /**
-     * Get all registered server configurations
-     */
-    getAll() {
-        return this.registry.getAll();
-    }
-    /**
-     * Get all registered server names
-     */
-    getServerNames() {
-        return this.registry.getServerNames();
-    }
-    /**
-     * Get plugin server configuration by server name
-     */
-    getPluginServer(serverName) {
-        return this.registeredPluginServers.get(serverName);
-    }
-    /**
-     * Get all registered plugin servers
-     */
-    getAllPluginServers() {
-        return Array.from(this.registeredPluginServers.values());
-    }
-    /**
-     * Check if a server is from a plugin
-     */
-    isPluginServer(serverName) {
-        return this.registeredPluginServers.has(serverName);
-    }
-    /**
-     * Unregister a plugin server
-     */
-    unregisterPluginServer(serverName) {
-        const config = this.registeredPluginServers.get(serverName);
-        if (!config)
-            return false;
-        // Remove from internal map
-        this.registeredPluginServers.delete(serverName);
-        // Remove from registry by recreating without that server
-        const allServers = this.registry.getAll();
-        this.registry.clear();
-        for (const server of allServers) {
-            if (server.serverName !== serverName) {
-                this.registry.register(server);
-            }
-        }
-        frameworkLogger.log("plugin-server-registry", "server-unregistered", "info", { serverName, plugin: config.pluginName });
-        return true;
-    }
-    /**
-     * Get servers by capability
-     */
-    getServersByCapability(capability) {
-        return this.getAllPluginServers().filter(config => config.capabilities?.includes(capability));
-    }
-    /**
-     * Get registry statistics
-     */
-    getRegistryStats() {
-        const allConfigs = this.getAll();
-        const pluginConfigs = this.getAllPluginServers();
-        const defaultCount = allConfigs.length - pluginConfigs.length;
-        return {
-            totalServers: allConfigs.length,
-            defaultServers: defaultCount,
-            pluginServers: pluginConfigs.length,
-            pluginServerDetails: pluginConfigs.map(c => ({
-                name: c.serverName,
-                plugin: c.pluginName,
-                version: c.pluginVersion,
-            })),
-        };
-    }
-    /**
-     * Clear all plugin server registrations (keep default servers)
-     */
-    clearPluginServers() {
-        const count = this.registeredPluginServers.size;
-        // Get all non-plugin servers and re-register them
-        const nonPluginServers = this.getAll().filter(server => !this.registeredPluginServers.has(server.serverName));
-        this.registry.clear();
-        for (const server of nonPluginServers) {
-            this.registry.register(server);
-        }
-        this.registeredPluginServers.clear();
-        frameworkLogger.log("plugin-server-registry", "plugin-servers-cleared", "info", { count });
-        return count;
-    }
-    /**
-     * Register a server configuration
-     */
-    register(config) {
-        this.registry.register(config);
-    }
-    /**
-     * Clear all registrations
-     */
-    clear() {
-        this.registry.clear();
-        this.registeredPluginServers.clear();
-    }
-    /**
-     * Create dynamic config for unknown server
-     */
-    createDynamicConfig(serverName) {
-        return this.registry.createDynamicConfig(serverName);
-    }
-}
-/**
- * Default singleton instance
- */
-export const defaultPluginServerRegistry = new PluginServerConfigRegistry();
-/**
- * Create a new PluginServerConfigRegistry
- */
-export function createPluginServerRegistry(baseRegistry) {
-    return new PluginServerConfigRegistry(baseRegistry);
-}

package/dist/mcps/config/server-config-registry.d.ts

@@ -1,51 +0,0 @@
-/**
- * Server Configuration Registry
- *
- * Manages server configurations with support for default servers
- * and runtime configuration registration.
- *
- * Extracted from mcp-client.ts as part of Phase 2 refactoring.
- */
-import { IServerConfig } from '../types/index.js';
-export declare class ServerConfigRegistry {
-    private configs;
-    constructor();
-    /**
-     * Register all default server configurations
-     */
-    private registerDefaultConfigs;
-    /**
-     * Register a new server configuration
-     */
-    register(config: IServerConfig): void;
-    /**
-     * Get a server configuration by name
-     */
-    get(serverName: string): IServerConfig | undefined;
-    /**
-     * Check if a server configuration exists
-     */
-    has(serverName: string): boolean;
-    /**
-     * Get all registered server configurations
-     */
-    getAll(): IServerConfig[];
-    /**
-     * Get all registered server names
-     */
-    getServerNames(): string[];
-    /**
-     * Clear all registered configurations
-     */
-    clear(): void;
-    /**
-     * Create a dynamic configuration for an unknown server
-     * Uses the knowledge-skills directory as default location.
-     * Now respects the "xray" field declared in package.json.
-     */
-    createDynamicConfig(serverName: string): IServerConfig;
-}
-/**
- * Default singleton instance of the server config registry
- */
-export declare const defaultServerRegistry: ServerConfigRegistry;

package/dist/mcps/config/server-config-registry.js

@@ -1,349 +0,0 @@
-/**
- * Server Configuration Registry
- *
- * Manages server configurations with support for default servers
- * and runtime configuration registration.
- *
- * Extracted from mcp-client.ts as part of Phase 2 refactoring.
- */
-import { frameworkLogger } from '../../core/framework-logger.js';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import fs from 'fs';
-/**
- * Registry for managing MCP server configurations
- */
-/**
- * Resolve the correct framework root and MCP servers path.
- * Priority:
- *   1. XRAY_DEV_PATH env var (explicit dev override)
- *   2. The "xray" field in the nearest package.json that declares it (works in both source tree and installed package)
- *   3. Safe fallback to node_modules/0xray/dist
- */
-function resolveFrameworkPaths() {
-    // Highest priority: explicit environment override
-    if (process.env.XRAY_DEV_PATH) {
-        const devPath = process.env.XRAY_DEV_PATH;
-        return {
-            frameworkRoot: devPath,
-            mcpServersPath: join(devPath, 'mcps'),
-        };
-    }
-    // Walk upward from this module to find the package that owns the "xray" config
-    let currentDir = dirname(fileURLToPath(import.meta.url));
-    // Safety limit to avoid walking the entire filesystem
-    const MAX_LEVELS = 12;
-    for (let i = 0; i < MAX_LEVELS; i++) {
-        const pkgPath = join(currentDir, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            try {
-                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-                if (pkg.name === '0xray') {
-                    const xrayCfg = (pkg.xray ?? {});
-                    const frameworkRoot = currentDir;
-                    const declaredMcp = xrayCfg.mcpServersPath ||
-                        (xrayCfg.dist ? join(xrayCfg.dist, 'mcps') : 'dist/mcps');
-                    return {
-                        frameworkRoot,
-                        mcpServersPath: join(frameworkRoot, declaredMcp),
-                    };
-                }
-            }
-            catch {
-                // ignore corrupt package.json
-            }
-        }
-        const parent = dirname(currentDir);
-        if (parent === currentDir)
-            break;
-        currentDir = parent;
-    }
-    // Final fallback (should almost never be reached)
-    const fallback = 'node_modules/0xray/dist';
-    frameworkLogger.log('server-config-registry', 'using-fallback-path', 'warning', {
-        reason: 'Could not locate xray package.json with "xray" field',
-        fallback,
-    });
-    return {
-        frameworkRoot: fallback,
-        mcpServersPath: join(fallback, 'mcps'),
-    };
-}
-export class ServerConfigRegistry {
-    configs = new Map();
-    constructor() {
-        this.registerDefaultConfigs();
-    }
-    /**
-     * Register all default server configurations
-     */
-    registerDefaultConfigs() {
-        const { mcpServersPath } = resolveFrameworkPaths();
-        const basePath = mcpServersPath;
-        // Code Review Server
-        this.register({
-            serverName: 'code-review',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/code-review.server.js`],
-            timeout: 30000,
-        });
-        // Security Audit Server
-        this.register({
-            serverName: 'security-audit',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/security-audit.server.js`],
-            timeout: 45000,
-        });
-        // Performance Optimization Server
-        this.register({
-            serverName: 'performance-optimization',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/performance-optimization.server.js`],
-            timeout: 30000,
-        });
-        // Testing Strategy Server
-        this.register({
-            serverName: 'testing-strategy',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/testing-strategy.server.js`],
-            timeout: 25000,
-        });
-        // Researcher Server
-        this.register({
-            serverName: 'researcher',
-            command: 'node',
-            args: [`${basePath}/researcher.server.js`],
-            timeout: 60000,
-        });
-        // Governance Service (meta-MCP that orchestrates the three skill servers + required external Dynamo)
-        this.register({
-            serverName: 'governance',
-            command: 'node',
-            args: [`${basePath}/governance.server.js`],
-            timeout: 120000, // Governance can take longer because it calls multiple servers + external
-        });
-        // Framework Help Server
-        this.register({
-            serverName: 'framework-help',
-            command: 'node',
-            args: [`${basePath}/framework-help.server.js`],
-            timeout: 15000,
-        });
-        // Skill Invocation Server
-        this.register({
-            serverName: 'skill-invocation',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/skill-invocation.server.js`],
-            timeout: 30000,
-        });
-        // Code Analyzer Server
-        this.register({
-            serverName: 'session-management',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/session-management.server.js`],
-            timeout: 30000,
-        });
-        // Code Analyzer Server
-        this.register({
-            serverName: 'code-analyzer',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/code-analyzer.server.js`],
-            timeout: 45000,
-        });
-        // Enforcer Server
-        this.register({
-            serverName: 'enforcer',
-            command: 'node',
-            args: [`${basePath}/enforcer-tools.server.js`],
-            timeout: 30000,
-        });
-        // Orchestrator Server
-        this.register({
-            serverName: 'orchestrator',
-            command: 'node',
-            args: [`${basePath}/orchestrator.server.js`],
-            timeout: 60000,
-        });
-        // Estimation Validator Server
-        this.register({
-            serverName: 'estimation-validator',
-            command: 'node',
-            args: [`${basePath}/estimation.server.js`],
-            timeout: 30000,
-        });
-        // Architect Server
-        this.register({
-            serverName: 'architect',
-            command: 'node',
-            args: [`${basePath}/architect-tools.server.js`],
-            timeout: 45000,
-        });
-        // Bug Triage Specialist Server
-        this.register({
-            serverName: 'bug-triage-specialist',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/bug-triage-specialist.server.js`],
-            timeout: 30000,
-        });
-        // Log Monitor Server
-        this.register({
-            serverName: 'log-monitor',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/log-monitor.server.js`],
-            timeout: 30000,
-        });
-        // Aliases to match features.json agent names
-        // Code Reviewer (alias for code-review)
-        this.register({
-            serverName: 'code-reviewer',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/code-review.server.js`],
-            timeout: 30000,
-        });
-        // Security Auditor (alias for security-audit)
-        this.register({
-            serverName: 'security-auditor',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/security-audit.server.js`],
-            timeout: 45000,
-        });
-        // Refactorer Server
-        this.register({
-            serverName: 'refactorer',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/refactoring-strategies.server.js`],
-            timeout: 40000,
-        });
-        // Testing Lead (alias for testing-strategy)
-        this.register({
-            serverName: 'testing-lead',
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/testing-strategy.server.js`],
-            timeout: 30000,
-        });
-        // Auto Format Server
-        this.register({
-            serverName: 'auto-format',
-            command: 'node',
-            args: [`${basePath}/auto-format.server.js`],
-            timeout: 30000,
-        });
-        // Boot Orchestrator Server
-        this.register({
-            serverName: 'boot-orchestrator',
-            command: 'node',
-            args: [`${basePath}/boot-orchestrator.server.js`],
-            timeout: 60000,
-        });
-        // Framework Compliance Audit Server
-        this.register({
-            serverName: 'framework-compliance-audit',
-            command: 'node',
-            args: [`${basePath}/framework-compliance-audit.server.js`],
-            timeout: 45000,
-        });
-        // Lint Server
-        this.register({
-            serverName: 'lint',
-            command: 'node',
-            args: [`${basePath}/lint.server.js`],
-            timeout: 30000,
-        });
-        // Performance Analysis Server
-        this.register({
-            serverName: 'performance-analysis',
-            command: 'node',
-            args: [`${basePath}/performance-analysis.server.js`],
-            timeout: 30000,
-        });
-        // Security Scan Server
-        this.register({
-            serverName: 'security-scan',
-            command: 'node',
-            args: [`${basePath}/security-scan.server.js`],
-            timeout: 45000,
-        });
-        // State Manager Server
-        this.register({
-            serverName: 'state-manager',
-            command: 'node',
-            args: [`${basePath}/state-manager.server.js`],
-            timeout: 30000,
-        });
-        // Processor Pipeline Server
-        this.register({
-            serverName: 'processor-pipeline',
-            command: 'node',
-            args: [`${basePath}/processor-pipeline.server.js`],
-            timeout: 30000,
-        });
-        // Model Health Check Server
-        this.register({
-            serverName: 'model-health-check',
-            command: 'node',
-            args: [`${basePath}/model-health-check.server.js`],
-            timeout: 30000,
-        });
-    }
-    /**
-     * Register a new server configuration
-     */
-    register(config) {
-        this.configs.set(config.serverName, config);
-    }
-    /**
-     * Get a server configuration by name
-     */
-    get(serverName) {
-        return this.configs.get(serverName);
-    }
-    /**
-     * Check if a server configuration exists
-     */
-    has(serverName) {
-        return this.configs.has(serverName);
-    }
-    /**
-     * Get all registered server configurations
-     */
-    getAll() {
-        return Array.from(this.configs.values());
-    }
-    /**
-     * Get all registered server names
-     */
-    getServerNames() {
-        return Array.from(this.configs.keys());
-    }
-    /**
-     * Clear all registered configurations
-     */
-    clear() {
-        this.configs.clear();
-    }
-    /**
-     * Create a dynamic configuration for an unknown server
-     * Uses the knowledge-skills directory as default location.
-     * Now respects the "xray" field declared in package.json.
-     */
-    createDynamicConfig(serverName) {
-        // Validate serverName against path traversal attacks
-        if (!serverName || serverName.includes('..') || serverName.includes('/') || serverName.includes('\\') || serverName.includes('\0')) {
-            const errorMsg = `Invalid server name "${serverName}": must not contain "..", "/", "\\", or null bytes`;
-            frameworkLogger.log("server-config-registry", "path-traversal-blocked", "warning", { serverName, error: errorMsg });
-            throw new Error(errorMsg);
-        }
-        const { mcpServersPath } = resolveFrameworkPaths();
-        const basePath = mcpServersPath;
-        return {
-            serverName,
-            command: 'node',
-            args: [`${basePath}/knowledge-skills/${serverName}.server.js`],
-            timeout: 30000,
-        };
-    }
-}
-/**
- * Default singleton instance of the server config registry
- */
-export const defaultServerRegistry = new ServerConfigRegistry();

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

@@ -1,39 +0,0 @@
-import { IMcpConnection, IServerConfig } from '../types/index.js';
-/**
- * Connection Manager
- * Manages MCP connection lifecycle and provides centralized access to connections
- */
-export declare class ConnectionManager {
-    private connections;
-    /**
-     * Get or create a connection for a server
-     * @param config - Server configuration
-     * @returns Promise resolving to an MCP connection
-     */
-    getConnection(config: IServerConfig): Promise<IMcpConnection>;
-    /**
-     * Disconnect a specific server
-     * @param serverName - Name of the server to disconnect
-     */
-    disconnect(serverName: string): Promise<void>;
-    /**
-     * Disconnect all managed connections
-     */
-    disconnectAll(): Promise<void>;
-    /**
-     * Check if a connection exists for a server
-     * @param serverName - Name of the server
-     * @returns True if connection exists and is connected
-     */
-    hasConnection(serverName: string): boolean;
-    /**
-     * Get all connected server names
-     * @returns Array of server names
-     */
-    getConnectedServers(): string[];
-    /**
-     * Get the number of active connections
-     * @returns Number of connections
-     */
-    getConnectionCount(): number;
-}