0xray 2.0.0

package/src/mcps/config/__tests__/server-config-registry.test.ts

@@ -0,0 +1,257 @@
+/**
+ * Server Configuration Registry Tests
+ * 
+ * Comprehensive tests for the ServerConfigRegistry class.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ServerConfigRegistry, defaultServerRegistry } from '../server-config-registry.js';
+
+describe('ServerConfigRegistry', () => {
+  let registry: ServerConfigRegistry;
+
+  beforeEach(() => {
+    registry = new ServerConfigRegistry();
+  });
+
+  describe('registration', () => {
+    it('should register a server config', () => {
+      registry.register({
+        serverName: 'test-server',
+        command: 'node',
+        args: ['test.js'],
+        timeout: 30000,
+      });
+
+      expect(registry.has('test-server')).toBe(true);
+    });
+
+    it('should retrieve a registered config', () => {
+      const config = {
+        serverName: 'test-server',
+        command: 'node',
+        args: ['test.js'],
+        timeout: 30000,
+      };
+      registry.register(config);
+
+      const retrieved = registry.get('test-server');
+      expect(retrieved).toEqual(config);
+    });
+
+    it('should return undefined for unknown server', () => {
+      expect(registry.get('unknown-server')).toBeUndefined();
+    });
+
+    it('should return false for unknown server in has()', () => {
+      expect(registry.has('unknown-server')).toBe(false);
+    });
+
+    it('should overwrite existing config on re-register', () => {
+      registry.register({
+        serverName: 'test-server',
+        command: 'node',
+        args: ['old.js'],
+        timeout: 30000,
+      });
+
+      registry.register({
+        serverName: 'test-server',
+        command: 'python',
+        args: ['new.py'],
+        timeout: 45000,
+      });
+
+      const retrieved = registry.get('test-server');
+      expect(retrieved?.command).toBe('python');
+      expect(retrieved?.args).toEqual(['new.py']);
+      expect(retrieved?.timeout).toBe(45000);
+    });
+  });
+
+  describe('default servers', () => {
+    it('should have code-review server registered by default', () => {
+      expect(registry.has('code-review')).toBe(true);
+      const config = registry.get('code-review');
+      expect(config?.command).toBe('node');
+      expect(config?.timeout).toBe(30000);
+    });
+
+    it('should have security-audit server registered by default', () => {
+      expect(registry.has('security-audit')).toBe(true);
+      const config = registry.get('security-audit');
+      expect(config?.timeout).toBe(45000);
+    });
+
+    it('should have security-auditor alias registered by default', () => {
+      expect(registry.has('security-auditor')).toBe(true);
+      const config = registry.get('security-auditor');
+      expect(config?.timeout).toBe(45000);
+    });
+
+    it('should have researcher server registered by default', () => {
+      expect(registry.has('researcher')).toBe(true);
+      const config = registry.get('researcher');
+      expect(config?.timeout).toBe(60000);
+    });
+
+    it('should have framework-help server registered by default', () => {
+      expect(registry.has('framework-help')).toBe(true);
+      const config = registry.get('framework-help');
+      expect(config?.timeout).toBe(15000);
+    });
+
+    it('should have orchestrator server registered by default', () => {
+      expect(registry.has('orchestrator')).toBe(true);
+      const config = registry.get('orchestrator');
+      expect(config?.timeout).toBe(60000);
+    });
+
+    it('should have architect server registered by default', () => {
+      expect(registry.has('architect')).toBe(true);
+      const config = registry.get('architect');
+      expect(config?.timeout).toBe(45000);
+    });
+
+    it('should have enforcer server registered by default', () => {
+      expect(registry.has('enforcer')).toBe(true);
+      const config = registry.get('enforcer');
+      expect(config?.timeout).toBe(30000);
+    });
+
+    it('should have all default servers registered', () => {
+      const names = registry.getServerNames();
+      expect(names.length).toBeGreaterThanOrEqual(15);
+    });
+
+    it('should include aliases in default registrations', () => {
+      expect(registry.has('code-reviewer')).toBe(true);
+      expect(registry.has('testing-lead')).toBe(true);
+    });
+  });
+
+  describe('bulk operations', () => {
+    it('should get all server names', () => {
+      const names = registry.getServerNames();
+      expect(names.length).toBeGreaterThan(0);
+      expect(names).toContain('code-review');
+      expect(names).toContain('security-audit');
+      expect(names).toContain('orchestrator');
+    });
+
+    it('should get all server configs', () => {
+      const configs = registry.getAll();
+      expect(configs.length).toBeGreaterThan(0);
+      
+      const codeReview = configs.find(c => c.serverName === 'code-review');
+      expect(codeReview).toBeDefined();
+      expect(codeReview?.command).toBe('node');
+    });
+
+    it('should clear all configs', () => {
+      registry.clear();
+      expect(registry.getAll()).toHaveLength(0);
+      expect(registry.getServerNames()).toHaveLength(0);
+    });
+  });
+
+  describe('dynamic config creation', () => {
+    it('should create dynamic config for unknown server', () => {
+      const config = registry.createDynamicConfig('custom-server');
+      expect(config.serverName).toBe('custom-server');
+      expect(config.command).toBe('node');
+      expect(config.args[0]).toContain('custom-server.server.js');
+      expect(config.timeout).toBe(30000);
+    });
+
+    it('should use STRRAY_DEV_PATH env var in dynamic config', () => {
+      const originalEnv = process.env.STRRAY_DEV_PATH;
+      process.env.STRRAY_DEV_PATH = 'custom-dist';
+      
+      const config = registry.createDynamicConfig('test-server');
+      expect(config.args[0]).toContain('custom-dist');
+      
+      process.env.STRRAY_DEV_PATH = originalEnv;
+    });
+  });
+
+  describe('environment path handling', () => {
+    it('should use resolved framework path when STRRAY_DEV_PATH is not set', () => {
+      const originalEnv = process.env.STRRAY_DEV_PATH;
+      delete process.env.STRRAY_DEV_PATH;
+      
+      const freshRegistry = new ServerConfigRegistry();
+      const config = freshRegistry.get('code-review');
+      expect(config?.args[0]).toContain('.server.js');
+      
+      process.env.STRRAY_DEV_PATH = originalEnv;
+    });
+
+    it('should use STRRAY_DEV_PATH when set', () => {
+      const originalEnv = process.env.STRRAY_DEV_PATH;
+      process.env.STRRAY_DEV_PATH = 'dist';
+      
+      const freshRegistry = new ServerConfigRegistry();
+      const config = freshRegistry.get('code-review');
+      expect(config?.args[0]).toContain('dist/');
+      
+      process.env.STRRAY_DEV_PATH = originalEnv;
+    });
+  });
+
+  describe('default singleton', () => {
+    it('defaultServerRegistry should be an instance', () => {
+      expect(defaultServerRegistry).toBeInstanceOf(ServerConfigRegistry);
+    });
+
+    it('defaultServerRegistry should have default servers', () => {
+      expect(defaultServerRegistry.has('code-review')).toBe(true);
+    });
+  });
+
+  describe('config structure', () => {
+    it('should have correct structure for all configs', () => {
+      const configs = registry.getAll();
+      
+      for (const config of configs) {
+        expect(config).toHaveProperty('serverName');
+        expect(config).toHaveProperty('command');
+        expect(config).toHaveProperty('args');
+        expect(config).toHaveProperty('timeout');
+        expect(typeof config.serverName).toBe('string');
+        expect(typeof config.command).toBe('string');
+        expect(Array.isArray(config.args)).toBe(true);
+        expect(typeof config.timeout).toBe('number');
+      }
+    });
+
+    it('should have valid timeouts for all configs', () => {
+      const configs = registry.getAll();
+      
+      for (const config of configs) {
+        expect(config.timeout).toBeGreaterThan(0);
+
+        // Governance (Dynamo Solar SSOT orchestrator) is allowed higher timeout
+        // because it coordinates multiple skill MCPs + required external filter.
+        const maxTimeout = config.serverName === 'governance' ? 120000 : 60000;
+        expect(config.timeout).toBeLessThanOrEqual(maxTimeout);
+      }
+    });
+
+    it('should use node command for all servers', () => {
+      const configs = registry.getAll();
+      
+      for (const config of configs) {
+        expect(config.command).toBe('node');
+      }
+    });
+
+    it('should have .js extension in all args', () => {
+      const configs = registry.getAll();
+      
+      for (const config of configs) {
+        expect(config.args[0]).toMatch(/\.js$/);
+      }
+    });
+  });
+});

package/src/mcps/config/config-loader.ts

@@ -0,0 +1,127 @@
+/**
+ * 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 * as fs from 'fs';
+import * as path from 'path';
+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 class ConfigLoader {
+  private configPaths: string[] = [
+    '.mcp.json',
+    '.opencode/mcp.json',
+    'mcp.config.json',
+  ];
+
+  /**
+   * Load configurations from available config files
+   * Returns empty array if no config file exists (this is valid)
+   */
+  async load(): Promise<ConfigLoadResult> {
+    for (const configPath of this.configPaths) {
+      if (fs.existsSync(configPath)) {
+        try {
+          const content = fs.readFileSync(configPath, 'utf-8');
+          const parsed = JSON.parse(content);
+          
+          // Handle both array format and object with servers property
+          const configs: IServerConfig[] = Array.isArray(parsed) 
+            ? parsed 
+            : parsed.servers || [];
+          
+          return { success: true, configs };
+        } catch (error) {
+          return {
+            success: false,
+            error: `Failed to load ${configPath}: ${error instanceof Error ? error.message : String(error)}`,
+          };
+        }
+      }
+    }
+    
+    // No config file is OK - return empty array
+    return { success: true, configs: [] };
+  }
+
+  /**
+   * Add a custom config path to search
+   */
+  addConfigPath(configPath: string): void {
+    this.configPaths.push(configPath);
+  }
+
+  /**
+   * Get all configured config paths
+   */
+  getConfigPaths(): string[] {
+    return [...this.configPaths];
+  }
+
+  /**
+   * Reset config paths to defaults
+   */
+  resetConfigPaths(): void {
+    this.configPaths = [
+      '.mcp.json',
+      '.opencode/mcp.json',
+      'mcp.config.json',
+    ];
+  }
+
+  /**
+   * Load configuration from a specific file path
+   */
+  async loadFromPath(filePath: string): Promise<ConfigLoadResult> {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return {
+          success: false,
+          error: `Config file not found: ${filePath}`,
+        };
+      }
+
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const parsed = JSON.parse(content);
+      
+      const configs: IServerConfig[] = Array.isArray(parsed) 
+        ? parsed 
+        : parsed.servers || [];
+      
+      return { success: true, configs };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to load ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+
+  /**
+   * Check if any config file exists
+   */
+  hasConfigFile(): boolean {
+    return this.configPaths.some(path => fs.existsSync(path));
+  }
+}
+
+/**
+ * Default singleton instance of the config loader
+ */
+export const defaultConfigLoader = new ConfigLoader();

package/src/mcps/config/config-validator.ts

@@ -0,0 +1,127 @@
+/**
+ * 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 class ConfigValidator {
+  /**
+   * Validate a single server configuration
+   */
+  validate(config: IServerConfig): ValidationResult {
+    const errors: string[] = [];
+
+    // Validate serverName
+    if (!config.serverName || typeof config.serverName !== 'string') {
+      errors.push('serverName is required and must be a string');
+    }
+
+    // Validate command
+    if (!config.command || typeof config.command !== 'string') {
+      errors.push('command is required and must be a string');
+    }
+
+    // Validate args
+    if (!config.args || !Array.isArray(config.args)) {
+      errors.push('args is required and must be an array');
+    } else {
+      // Check that all args are strings
+      const nonStringArgs = config.args.filter(arg => typeof arg !== 'string');
+      if (nonStringArgs.length > 0) {
+        errors.push('all args must be strings');
+      }
+    }
+
+    // Validate timeout (optional but must be number if provided)
+    if (config.timeout !== undefined && typeof config.timeout !== 'number') {
+      errors.push('timeout must be a number when provided');
+    }
+
+    // Validate timeout is positive
+    if (config.timeout !== undefined && config.timeout <= 0) {
+      errors.push('timeout must be a positive number');
+    }
+
+    // Validate env (optional but must be object if provided)
+    if (config.env !== undefined) {
+      if (typeof config.env !== 'object' || config.env === null) {
+        errors.push('env must be an object when provided');
+      } else {
+        // Check that all env values are strings
+        const nonStringEnvValues = Object.entries(config.env).filter(
+          ([, value]) => typeof value !== 'string'
+        );
+        if (nonStringEnvValues.length > 0) {
+          errors.push('all env values must be strings');
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+    };
+  }
+
+  /**
+   * Validate multiple server configurations
+   */
+  validateAll(configs: IServerConfig[]): ValidationResult {
+    const allErrors: string[] = [];
+
+    for (const config of configs) {
+      const result = this.validate(config);
+      if (!result.valid) {
+        allErrors.push(...result.errors.map(e => `${config.serverName || 'unknown'}: ${e}`));
+      }
+    }
+
+    return {
+      valid: allErrors.length === 0,
+      errors: allErrors,
+    };
+  }
+
+  /**
+   * Validate and filter - returns only valid configs
+   */
+  filterValid(configs: IServerConfig[]): IServerConfig[] {
+    return configs.filter(config => this.validate(config).valid);
+  }
+
+  /**
+   * Get validation errors for all invalid configs
+   */
+  getValidationErrors(configs: IServerConfig[]): Record<string, string[]> {
+    const errors: Record<string, string[]> = {};
+
+    for (const config of configs) {
+      const result = this.validate(config);
+      if (!result.valid) {
+        errors[config.serverName || 'unknown'] = result.errors;
+      }
+    }
+
+    return errors;
+  }
+}
+
+/**
+ * Default singleton instance of the config validator
+ */
+export const defaultConfigValidator = new ConfigValidator();

package/src/mcps/config/index.ts

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