0xray 4.0.12 → 4.0.13

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

@@ -1,56 +0,0 @@
-/**
- * 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;
-    /**
-     * Clear all config paths
-     */
-    clearConfigPaths(): 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-loader.js

@@ -1,140 +0,0 @@
-/**
- * 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';
-/**
- * Loads MCP server configurations from files
- */
-export class ConfigLoader {
-    configPaths = [
-        '.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() {
-        for (const configPath of this.configPaths) {
-            if (fs.existsSync(configPath)) {
-                try {
-                    const content = fs.readFileSync(configPath, 'utf-8');
-                    const parsed = JSON.parse(content);
-                    // Handle array format
-                    if (Array.isArray(parsed)) {
-                        return { success: true, configs: parsed };
-                    }
-                    // Handle standard MCP format (mcpServers object — Claude/OpenCode .mcp.json)
-                    if (parsed.mcpServers && typeof parsed.mcpServers === 'object') {
-                        const configs = Object.entries(parsed.mcpServers).map(([serverName, config]) => ({
-                            serverName,
-                            command: config.command || '',
-                            args: config.args || [],
-                            timeout: config.timeout ?? 30000,
-                            env: config.env,
-                        }));
-                        return { success: true, configs };
-                    }
-                    // Handle object with servers property
-                    if (parsed.servers) {
-                        return { success: true, configs: 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) {
-        this.configPaths.push(configPath);
-    }
-    /**
-     * Get all configured config paths
-     */
-    getConfigPaths() {
-        return [...this.configPaths];
-    }
-    /**
-     * Reset config paths to defaults
-     */
-    resetConfigPaths() {
-        this.configPaths = [
-            '.mcp.json',
-            '.opencode/mcp.json',
-            'mcp.config.json',
-        ];
-    }
-    /**
-     * Clear all config paths
-     */
-    clearConfigPaths() {
-        this.configPaths = [];
-    }
-    /**
-     * Load configuration from a specific file path
-     */
-    async loadFromPath(filePath) {
-        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);
-            // Handle array format
-            if (Array.isArray(parsed)) {
-                return { success: true, configs: parsed };
-            }
-            // Handle standard MCP format (mcpServers object)
-            if (parsed.mcpServers && typeof parsed.mcpServers === 'object') {
-                const configs = Object.entries(parsed.mcpServers).map(([serverName, config]) => ({
-                    serverName,
-                    command: config.command || '',
-                    args: config.args || [],
-                    timeout: config.timeout ?? 30000,
-                    env: config.env,
-                }));
-                return { success: true, configs };
-            }
-            // Handle object with servers property
-            if (parsed.servers) {
-                return { success: true, configs: 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() {
-        return this.configPaths.some(path => fs.existsSync(path));
-    }
-}
-/**
- * Default singleton instance of the config loader
- */
-export const defaultConfigLoader = new ConfigLoader();

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

@@ -1,40 +0,0 @@
-/**
- * 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/config-validator.js

@@ -1,101 +0,0 @@
-/**
- * Configuration Validator
- *
- * Validates MCP server configurations for completeness and correctness.
- *
- * Extracted from mcp-client.ts as part of Phase 2 refactoring.
- */
-/**
- * Validates MCP server configurations
- */
-export class ConfigValidator {
-    /**
-     * Validate a single server configuration
-     */
-    validate(config) {
-        const errors = [];
-        // 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) {
-        const allErrors = [];
-        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) {
-        return configs.filter(config => this.validate(config).valid);
-    }
-    /**
-     * Get validation errors for all invalid configs
-     */
-    getValidationErrors(configs) {
-        const errors = {};
-        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/dist/mcps/config/index.d.ts

@@ -1,31 +0,0 @@
-/**
- * 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/index.js

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

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

@@ -1,126 +0,0 @@
-/**
- * Server Configuration Registry - Plugin Extension
- *
- * Extends ServerConfigRegistry with plugin support for Phase 2.
- * Enables automatic MCP server registration from plugins.
- *
- */
-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;