0xray 2.0.0 → 2.1.0

package/dist/mcps/boot-orchestrator.server.js

@@ -11,7 +11,7 @@ import fs from "fs";
 import path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { resolveLogDir, resolveStateDir } from "../core/config-paths.js";
-class StringRayBootOrchestratorServer {
+class XrayBootOrchestratorServer {
     server;
     bootStatus;
     // Boot sequence in dependency order
@@ -30,7 +30,7 @@ class StringRayBootOrchestratorServer {
     ];
     constructor() {
         this.server = new Server({
-            name: "boot-orchestrator", version: "1.22.67",
+            name: "boot-orchestrator", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -847,7 +847,7 @@ ${results.warnings.length > 0 ? `**Warnings:**\n${results.warnings.map((w) => `
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayBootOrchestratorServer();
+    const server = new XrayBootOrchestratorServer();
     server.run().catch((error) => frameworkLogger.log("mcps/boot-orchestrator", "run", "error", { error: String(error) }));
 }
-export { StringRayBootOrchestratorServer };
+export { XrayBootOrchestratorServer };

package/dist/mcps/config/config-loader.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Configuration Loader
+ *
+ * Loads MCP server configurations from various sources including
+ * JSON configuration files.
+ *
+ * Extracted from mcp-client.ts as part of Phase 2 refactoring.
+ */
+import { IServerConfig } from '../types/index.js';
+/**
+ * Result of a configuration load operation
+ */
+export interface ConfigLoadResult {
+    success: boolean;
+    configs?: IServerConfig[];
+    error?: string;
+}
+/**
+ * Loads MCP server configurations from files
+ */
+export declare class ConfigLoader {
+    private configPaths;
+    /**
+     * Load configurations from available config files
+     * Returns empty array if no config file exists (this is valid)
+     */
+    load(): Promise<ConfigLoadResult>;
+    /**
+     * Add a custom config path to search
+     */
+    addConfigPath(configPath: string): void;
+    /**
+     * Get all configured config paths
+     */
+    getConfigPaths(): string[];
+    /**
+     * Reset config paths to defaults
+     */
+    resetConfigPaths(): void;
+    /**
+     * Load configuration from a specific file path
+     */
+    loadFromPath(filePath: string): Promise<ConfigLoadResult>;
+    /**
+     * Check if any config file exists
+     */
+    hasConfigFile(): boolean;
+}
+/**
+ * Default singleton instance of the config loader
+ */
+export declare const defaultConfigLoader: ConfigLoader;

package/dist/mcps/config/config-validator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Configuration Validator
+ *
+ * Validates MCP server configurations for completeness and correctness.
+ *
+ * Extracted from mcp-client.ts as part of Phase 2 refactoring.
+ */
+import { IServerConfig } from '../types/index.js';
+/**
+ * Result of a configuration validation
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Validates MCP server configurations
+ */
+export declare class ConfigValidator {
+    /**
+     * Validate a single server configuration
+     */
+    validate(config: IServerConfig): ValidationResult;
+    /**
+     * Validate multiple server configurations
+     */
+    validateAll(configs: IServerConfig[]): ValidationResult;
+    /**
+     * Validate and filter - returns only valid configs
+     */
+    filterValid(configs: IServerConfig[]): IServerConfig[];
+    /**
+     * Get validation errors for all invalid configs
+     */
+    getValidationErrors(configs: IServerConfig[]): Record<string, string[]>;
+}
+/**
+ * Default singleton instance of the config validator
+ */
+export declare const defaultConfigValidator: ConfigValidator;

package/dist/mcps/config/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MCP Configuration Layer
+ *
+ * Centralized configuration management for MCP servers.
+ *
+ * This module provides:
+ * - ServerConfigRegistry: Manages server configurations
+ * - ConfigLoader: Loads configurations from files
+ * - ConfigValidator: Validates configuration correctness
+ *
+ * @example
+ * ```typescript
+ * import { defaultServerRegistry, ConfigLoader, ConfigValidator } from './config/index.js';
+ *
+ * // Get a server config
+ * const config = defaultServerRegistry.get('code-review');
+ *
+ * // Load from file
+ * const loader = new ConfigLoader();
+ * const result = await loader.load();
+ *
+ * // Validate
+ * const validator = new ConfigValidator();
+ * const validation = validator.validate(config);
+ * ```
+ */
+export { ServerConfigRegistry, defaultServerRegistry } from './server-config-registry.js';
+export { ConfigLoader, defaultConfigLoader } from './config-loader.js';
+export { ConfigValidator, defaultConfigValidator } from './config-validator.js';
+export { PluginServerConfigRegistry } from './plugin-server-registry.js';
+export type { PluginServerConfig, PluginServerRegistrationOptions } from './plugin-server-registry.js';

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

@@ -0,0 +1,127 @@
+/**
+ * Server Configuration Registry - Plugin Extension
+ *
+ * Extends ServerConfigRegistry with plugin support for Phase 2.
+ * Enables automatic MCP server registration from plugins.
+ *
+ * @version 1.2.0
+ */
+import { ServerConfigRegistry } from "./server-config-registry.js";
+import { IServerConfig } from "../types/mcp.types.js";
+import type { PluginIntegration } from "../../integrations/plugins/plugin-integration.js";
+import type { PluginRegistry } from "../../integrations/plugins/plugin-registry.js";
+/**
+ * Plugin server configuration
+ */
+export interface PluginServerConfig extends IServerConfig {
+    pluginName: string;
+    pluginVersion: string;
+    autoReload?: boolean;
+    capabilities?: string[];
+}
+/**
+ * Plugin server registration options
+ */
+export interface PluginServerRegistrationOptions {
+    registry?: ServerConfigRegistry;
+    autoRegister?: boolean;
+    overwrite?: boolean;
+}
+/**
+ * ServerConfigRegistry with plugin support
+ */
+export declare class PluginServerConfigRegistry {
+    private registry;
+    private registeredPluginServers;
+    private pluginRegistryRef?;
+    constructor(registry?: ServerConfigRegistry);
+    /**
+     * Set the plugin registry reference for dynamic updates
+     */
+    setPluginRegistry(registry: PluginRegistry): void;
+    /**
+     * Get the plugin registry reference
+     */
+    getPluginRegistry(): PluginRegistry | undefined;
+    /**
+     * Register a plugin's MCP server configuration
+     */
+    registerPluginServer(plugin: PluginIntegration, options?: PluginServerRegistrationOptions): boolean;
+    /**
+     * Register all MCP server plugins from a plugin registry
+     */
+    registerAllPluginServers(pluginRegistry: PluginRegistry, options?: PluginServerRegistrationOptions): number;
+    /**
+     * 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[];
+    /**
+     * Get plugin server configuration by server name
+     */
+    getPluginServer(serverName: string): PluginServerConfig | undefined;
+    /**
+     * Get all registered plugin servers
+     */
+    getAllPluginServers(): PluginServerConfig[];
+    /**
+     * Check if a server is from a plugin
+     */
+    isPluginServer(serverName: string): boolean;
+    /**
+     * Unregister a plugin server
+     */
+    unregisterPluginServer(serverName: string): boolean;
+    /**
+     * Get servers by capability
+     */
+    getServersByCapability(capability: string): PluginServerConfig[];
+    /**
+     * Get registry statistics
+     */
+    getRegistryStats(): {
+        totalServers: number;
+        defaultServers: number;
+        pluginServers: number;
+        pluginServerDetails: Array<{
+            name: string;
+            plugin: string;
+            version: string;
+        }>;
+    };
+    /**
+     * Clear all plugin server registrations (keep default servers)
+     */
+    clearPluginServers(): number;
+    /**
+     * Register a server configuration
+     */
+    register(config: IServerConfig): void;
+    /**
+     * Clear all registrations
+     */
+    clear(): void;
+    /**
+     * Create dynamic config for unknown server
+     */
+    createDynamicConfig(serverName: string): IServerConfig;
+}
+/**
+ * Default singleton instance
+ */
+export declare const defaultPluginServerRegistry: PluginServerConfigRegistry;
+/**
+ * Create a new PluginServerConfigRegistry
+ */
+export declare function createPluginServerRegistry(baseRegistry?: ServerConfigRegistry): PluginServerConfigRegistry;

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

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

@@ -17,7 +17,7 @@ import fs from 'fs';
  * Resolve the correct framework root and MCP servers path.
  * Priority:
  *   1. STRRAY_DEV_PATH env var (explicit dev override)
- *   2. The "strray" field in the nearest package.json that declares it (works in both source tree and installed package)
+ *   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() {
@@ -29,7 +29,7 @@ function resolveFrameworkPaths() {
             mcpServersPath: join(devPath, 'mcps'),
         };
     }
-    // Walk upward from this module to find the package that owns the "strray" config
+    // 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;
@@ -38,10 +38,10 @@ function resolveFrameworkPaths() {
         if (fs.existsSync(pkgPath)) {
             try {
                 const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-                if (pkg.name === '0xray' && pkg.strray) {
-                    const strrayCfg = pkg.strray;
+                if (pkg.name === '0xray' && pkg.xray) {
+                    const xrayCfg = pkg.xray;
                     const frameworkRoot = currentDir;
-                    const declaredMcp = strrayCfg.mcpServersPath || (strrayCfg.dist ? join(strrayCfg.dist, 'mcps') : 'dist/mcps');
+                    const declaredMcp = xrayCfg.mcpServersPath || (xrayCfg.dist ? join(xrayCfg.dist, 'mcps') : 'dist/mcps');
                     return {
                         frameworkRoot,
                         mcpServersPath: join(frameworkRoot, declaredMcp),
@@ -60,7 +60,7 @@ function resolveFrameworkPaths() {
     // 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 strray package.json with "strray" field',
+        reason: 'Could not locate xray package.json with "xray" field',
         fallback,
     });
     return {
@@ -323,7 +323,7 @@ export class ServerConfigRegistry {
     /**
      * Create a dynamic configuration for an unknown server
      * Uses the knowledge-skills directory as default location.
-     * Now respects the "strray" field declared in package.json.
+      * Now respects the "xray" field declared in package.json.
      */
     createDynamicConfig(serverName) {
         // Validate serverName against path traversal attacks

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

@@ -0,0 +1,39 @@
+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;
+}

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/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

@@ -52,7 +52,7 @@ export class McpConnection extends EventEmitter {
                     protocolVersion: MCP_PROTOCOL_VERSION,
                     capabilities: {},
                     clientInfo: {
-                        name: 'strray-mcp-client',
+                        name: 'xray-mcp-client',
                         version: '1.7.5',
                     },
                 },

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/enforcer-tools.server.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 0xRay Enforcer Tools MCP Server
+ *
+ * Converts enforcer-tools.ts functions into MCP server tools
+ * Provides rule enforcement and validation capabilities via MCP protocol
+ */
+declare class XrayEnforcerToolsServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    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;
+    run(): Promise<void>;
+    private securityScan;
+}
+export default XrayEnforcerToolsServer;

package/dist/mcps/enforcer-tools.server.js

@@ -12,11 +12,11 @@ import { frameworkLogger } from "../core/framework-logger.js";
 import { getCodexPolicyService } from "../governance/codex-policy.service.js";
 // Import actual enforcer-tools functions
 import { ruleValidation as runRuleValidation } from "../enforcement/enforcer-tools.js";
-class StringRayEnforcerToolsServer {
+class XrayEnforcerToolsServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "enforcer", version: "1.22.67",
+            name: "enforcer", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -772,7 +772,7 @@ class StringRayEnforcerToolsServer {
     }
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayEnforcerToolsServer();
+    const server = new XrayEnforcerToolsServer();
     server.run().catch((error) => frameworkLogger.log("mcps/enforcer", "run", "error", { error: String(error) }));
 }
-export default StringRayEnforcerToolsServer;
+export default XrayEnforcerToolsServer;

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

@@ -0,0 +1,21 @@
+/**
+ * Estimation MCP Server
+ *
+ * Provides tools for tracking and validating estimates
+ */
+/**
+ * Estimation MCP Server
+ * Tracks estimates vs actuals and provides calibrated predictions
+ */
+declare class EstimationServer {
+    private server;
+    private validator;
+    constructor();
+    private setupToolHandlers;
+    private handleValidateEstimate;
+    private handleStartTracking;
+    private handleCompleteTracking;
+    private handleGetReport;
+    start(): Promise<void>;
+}
+export { EstimationServer };

package/dist/mcps/estimation.server.js

@@ -17,7 +17,7 @@ class EstimationServer {
     validator = getEstimationValidator();
     constructor() {
         this.server = new Server({
-            name: "estimation-validator", version: "1.22.67",
+            name: "estimation-validator", version: "2.0.0",
         }, {
             capabilities: { tools: {} },
         });