0xray 3.4.1 → 3.4.3

package/dist/integrations/plugins/plugin-registry.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Plugin Registry
+ *
+ * Industrial-grade plugin registry for managing 0xRay plugins.
+ * Provides discovery, loading, lifecycle management, dependency resolution,
+ * and comprehensive observability.
+ *
+ * Features:
+ * - Auto-discovery from filesystem
+ * - Dependency resolution and validation
+ * - Plugin state management
+ * - Batch operations with error recovery
+ * - Comprehensive health monitoring
+ * - Metrics aggregation
+ * - Event-driven architecture
+ *
+ */
+import { EventEmitter } from "events";
+import { IntegrationRegistry } from "../base/registry.js";
+import { PluginIntegration, PluginRoutingMapping, PluginType, PluginState } from "./plugin-integration.js";
+export interface PluginRegistryConfig {
+    pluginsDir: string;
+    configPath?: string;
+    autoStart?: boolean;
+    enableMetrics?: boolean;
+    maxRestarts?: number;
+    restartDelayMs?: number;
+}
+export interface PluginLoadResult {
+    name: string;
+    success: boolean;
+    error?: string;
+    plugin?: PluginIntegration;
+}
+export interface PluginStatus {
+    name: string;
+    type: string;
+    version: string;
+    state: PluginState;
+    enabled: boolean;
+    healthy: boolean;
+    uptime: number;
+    restarts: number;
+}
+export interface RegistryMetrics {
+    totalPlugins: number;
+    activePlugins: number;
+    enabledPlugins: number;
+    errorPlugins: number;
+    totalToolCalls: number;
+    totalErrors: number;
+    pluginsByType: Record<string, number>;
+}
+export interface DependencyInfo {
+    name: string;
+    version: string;
+    satisfied: boolean;
+    optional: boolean;
+}
+/**
+ * Plugin Registry Events
+ */
+export type PluginRegistryEventType = "plugin-loaded" | "plugin-unloaded" | "plugin-enabled" | "plugin-disabled" | "plugin-reloaded" | "plugin-error" | "discovery-complete" | "dependency-resolved" | "dependency-missing" | "metrics-updated" | "error";
+export interface PluginRegistryEvent {
+    type: PluginRegistryEventType;
+    timestamp: number;
+    pluginName?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+    error?: Error | undefined;
+}
+/**
+ * Plugin Registry
+ *
+ * Manages plugins as integrations, leveraging:
+ * - IntegrationRegistry for lifecycle management
+ * - ServerConfigRegistry for MCP server registration
+ * - Enforcer routing for skill mappings
+ */
+export declare class PluginRegistry extends EventEmitter {
+    private pluginsDir;
+    private configPath;
+    private autoStart;
+    private enableMetrics;
+    private enableHotReload;
+    private maxRestarts;
+    private restartDelayMs;
+    private plugins;
+    private integrationRegistry;
+    private initialized;
+    private metricsInterval?;
+    private watcher?;
+    private reloadDebounce;
+    constructor(config?: Partial<PluginRegistryConfig & {
+        enableHotReload?: boolean;
+    }>);
+    /**
+     * Initialize the registry and discover plugins
+     */
+    initialize(): Promise<void>;
+    /**
+     * Ensure required directories exist
+     */
+    private ensureDirectories;
+    /**
+     * Discover and load plugins from plugins directory
+     */
+    private discoverPlugins;
+    /**
+     * Validate plugin dependencies
+     */
+    private validateDependencies;
+    /**
+     * Load a single plugin
+     */
+    loadPlugin(name: string): Promise<PluginIntegration | null>;
+    /**
+     * Parse plugin type from string
+     */
+    private parsePluginType;
+    /**
+     * Unload a plugin
+     */
+    unloadPlugin(name: string): Promise<boolean>;
+    /**
+     * Enable a plugin
+     */
+    enablePlugin(name: string): Promise<boolean>;
+    /**
+     * Disable a plugin
+     */
+    disablePlugin(name: string): Promise<boolean>;
+    /**
+     * Restart a plugin
+     */
+    restartPlugin(name: string): Promise<boolean>;
+    /**
+     * Get a plugin by name
+     */
+    getPlugin(name: string): PluginIntegration | undefined;
+    /**
+     * Get all plugins
+     */
+    getAllPlugins(): PluginIntegration[];
+    /**
+     * Get plugins by type
+     */
+    getPluginsByType(type: PluginType): PluginIntegration[];
+    /**
+     * Get plugins by state
+     */
+    getPluginsByState(state: PluginState): PluginIntegration[];
+    /**
+     * Get active MCP server configurations
+     */
+    getMcpServerConfigs(): Array<{
+        serverName: string;
+        command: string;
+        args?: string[];
+        env?: Record<string, string>;
+        timeout?: number;
+    }>;
+    /**
+     * Get all routing mappings from plugins
+     */
+    getAllRoutingMappings(): PluginRoutingMapping[];
+    /**
+     * Get all tools from plugins
+     */
+    getAllTools(): Array<{
+        name: string;
+        description: string;
+        plugin: string;
+    }>;
+    /**
+     * Health check all plugins
+     */
+    healthCheckAll(): Promise<Record<string, {
+        healthy: boolean;
+        message: string;
+        details?: Record<string, unknown>;
+    }>>;
+    /**
+     * Get aggregated metrics
+     */
+    getMetrics(): RegistryMetrics;
+    /**
+     * Start metrics collection interval
+     */
+    private startMetricsCollection;
+    /**
+     * Start file watcher for hot-reload
+     */
+    private startFileWatcher;
+    /**
+     * Debounce plugin reload to avoid multiple reloads during file writes
+     */
+    private debounceReload;
+    /**
+     * Hot-reload a single plugin
+     */
+    private hotReloadPlugin;
+    /**
+     * Shutdown all plugins
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get status summary
+     */
+    getStatus(): {
+        initialized: boolean;
+        pluginCount: number;
+        plugins: PluginStatus[];
+        metrics: RegistryMetrics;
+    };
+    /**
+     * Get the underlying IntegrationRegistry
+     */
+    getIntegrationRegistry(): IntegrationRegistry;
+    /**
+     * Emit a registry event
+     */
+    private emitEvent;
+}

package/dist/mcps/agent-resolver.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Agent Resolver
+ *
+ * Resolves agent configurations from the 0xRay registry.
+ * Used by the integration layer to programmatically access agent configs.
+ *
+ * @since 2026-02-14
+ */
+interface AgentConfig {
+    name: string;
+    description?: string;
+    capabilities?: string[];
+    system?: string;
+    tools?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    model?: string;
+    mode?: string;
+    temperature?: number;
+    maxComplexity?: number;
+    enabled?: boolean;
+    permission?: {
+        edit?: string;
+        bash?: string;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Resolves an agent configuration by name from the 0xRay registry
+ *
+ * @param agentName - The name of the agent to resolve
+ * @returns The agent configuration object
+ * @throws Error if agent cannot be resolved
+ */
+export declare function resolveAgent(agentName: string): Promise<AgentConfig>;
+/**
+ * Gets all available agents from the registry
+ */
+export declare function getAllAgents(): Promise<string[]>;
+/**
+ * Checks if an agent exists in the registry
+ */
+export declare function agentExists(agentName: string): Promise<boolean>;
+export {};

package/dist/mcps/architect-tools.server.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 0xRay Architect Tools MCP Server
+ *
+ * Converts architect-tools.ts functions into MCP server tools
+ * Provides contextual analysis capabilities via MCP protocol
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
+    constructor();
+    setupToolHandlers(): void;
+    private contextAnalysis;
+    private codebaseStructure;
+    private dependencyAnalysis;
+    private architectureAssessment;
+}
+export default XrayArchitectToolsServer;

package/dist/mcps/auto-format.server.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 0xRay Auto Format MCP Server
+ *
+ * Automated code formatting hook with Prettier and framework-specific formatters
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayAutoFormatServer extends XrayKnowledgeSkillBase {
+    constructor();
+    setupToolHandlers(): void;
+    private handleAutoFormat;
+    private handleFormatCheck;
+    private runPrettier;
+    private runEslintFix;
+    private runTypeScriptFormat;
+    private checkFormatting;
+    private generateFormatSummary;
+}
+export { XrayAutoFormatServer };

package/dist/mcps/boot-orchestrator.server.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 0xRay Boot Orchestrator MCP Server
+ *
+ * Advanced initialization orchestration with dependency management and health monitoring
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayBootOrchestratorServer extends XrayKnowledgeSkillBase {
+    private bootStatus;
+    private bootSequence;
+    constructor();
+    private initializeDependencies;
+    setupToolHandlers(): void;
+    private handleExecuteBootSequence;
+    private handleGetBootStatus;
+    private handleInitializeComponent;
+    private handleValidateBootDependencies;
+    private handleShutdownFramework;
+    private validatePrerequisites;
+    private executeParallelBoot;
+    private executeSequentialBoot;
+    private initializeComponent;
+    private initConfiguration;
+    private initLogging;
+    private initStateManagement;
+    private initSecurity;
+    private initCodexLoader;
+    private initContextLoader;
+    private initProcessorPipeline;
+    private initAgentRegistry;
+    private initOrchestrator;
+    private initMCPServers;
+    private initFrameworkHooks;
+    private countAgentFiles;
+    private countMCPFiles;
+    private getComponentStatus;
+    private getOverallBootStatus;
+    private validateAllDependencies;
+    private checkComponentExists;
+    private detectCircularDependencies;
+    private applyDependencyFixes;
+    private executeShutdownSequence;
+    private shutdownComponent;
+    private saveShutdownState;
+    private formatBootResults;
+    private formatComponentStatus;
+    private formatOverallStatus;
+}
+export { XrayBootOrchestratorServer };

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

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

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

@@ -38,10 +38,11 @@ function resolveFrameworkPaths() {
         if (fs.existsSync(pkgPath)) {
             try {
                 const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-                if (pkg.name === '0xray' && pkg.xray) {
-                    const xrayCfg = pkg.xray;
+                if (pkg.name === '0xray') {
+                    const xrayCfg = (pkg.xray ?? {});
                     const frameworkRoot = currentDir;
-                    const declaredMcp = xrayCfg.mcpServersPath || (xrayCfg.dist ? join(xrayCfg.dist, 'mcps') : 'dist/mcps');
+                    const declaredMcp = xrayCfg.mcpServersPath ||
+                        (xrayCfg.dist ? join(xrayCfg.dist, 'mcps') : 'dist/mcps');
                     return {
                         frameworkRoot,
                         mcpServersPath: join(frameworkRoot, declaredMcp),