0xray 2.0.0 → 2.0.1

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 "strray" 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/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/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 StringRayEnforcerToolsServer {
+    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 StringRayEnforcerToolsServer;

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

@@ -16,7 +16,7 @@ class StringRayEnforcerToolsServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "enforcer", version: "1.22.67",
+            name: "enforcer", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

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: {} },
         });

package/dist/mcps/framework-compliance-audit.server.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 0xRay Framework Compliance Audit MCP Server
+ *
+ * Comprehensive validation of all framework components and Universal Development Codex compliance
+ */
+declare class StringRayFrameworkComplianceAuditServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private handleFrameworkComplianceAudit;
+    private handleCodexValidation;
+    private auditConfigurationIntegrity;
+    private auditAgentConfigurations;
+    private auditCodexCompliance;
+    private auditPerformanceThresholds;
+    private validateCodexTerms;
+    private checkTermImplementation;
+    private generateAuditSummary;
+    private getDetailedFindings;
+    run(): Promise<void>;
+}
+export { StringRayFrameworkComplianceAuditServer };

package/dist/mcps/framework-compliance-audit.server.js

@@ -12,7 +12,7 @@ class StringRayFrameworkComplianceAuditServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "framework-compliance-audit", version: "1.22.67",
+            name: "framework-compliance-audit", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/framework-help.server.d.ts

@@ -0,0 +1,14 @@
+declare class FrameworkHelpServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private getActiveAgentEntries;
+    private handleGetCapabilities;
+    private handleGetCommands;
+    private handleExplainCapability;
+    private generateCommandList;
+    private generateFullCapabilities;
+    private generateCategoryCapabilities;
+    start(): Promise<void>;
+}
+export { FrameworkHelpServer };

package/dist/mcps/framework-help.server.js

@@ -7,7 +7,7 @@ class FrameworkHelpServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "xray/framework-help", version: "1.22.67",
+            name: "xray/framework-help", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

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

@@ -0,0 +1,33 @@
+/**
+ * 0xRay Governance MCP Server
+ *
+ * First-class Governance Service that orchestrates the real individual
+ * skill MCP servers (code-review, security-audit, researcher) plus the
+ * required Dynamo Solar SSOT filter.
+ *
+ * This is the primary governance entry point for all integrations
+ * (Hermes, OpenCode, OpenClaw, Grok CLI, Jelly, CI/CD).
+ *
+ * It always runs proposals through the three real skill servers
+ * and the Dynamo Solar SSOT filter (required by default).
+ */
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+declare class GovernanceServer {
+    private server;
+    constructor();
+    private validateGovernProposalsArgs;
+    private validateGovernReflectionArgs;
+    private setupToolHandlers;
+    private handleGovernProposals;
+    private handleGovernReflection;
+    private handleGetActiveCodex;
+    private parseCodexTermsFromReflection;
+    private initializeGovernance;
+    run(): Promise<void>;
+    connect(transport: Transport): Promise<void>;
+    /**
+     * Run as HTTP server using Streamable HTTP transport (for Grok CLI compatibility).
+     */
+    runHttp(port?: number): Promise<void>;
+}
+export { GovernanceServer };

package/dist/mcps/in-process-skill-registry.d.ts

@@ -0,0 +1,20 @@
+interface AnalyzeProposalArgs {
+    proposalTitle?: string;
+    proposalDescription?: string;
+    evidence?: string[];
+    proposalType?: string;
+}
+export interface MCPToolResult {
+    content?: Array<{
+        type: string;
+        text: string;
+    }>;
+}
+interface AnalyzeProposalResult {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+}
+export declare function callInProcessSkill(serverName: string, toolName: string, args: Record<string, unknown>): Promise<AnalyzeProposalResult>;
+export type { AnalyzeProposalArgs, AnalyzeProposalResult };