0xray 2.0.0 → 2.1.0

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

@@ -0,0 +1,289 @@
+/**
+ * Plugin Integration
+ *
+ * Industrial-grade plugin system extending the existing Integration architecture.
+ * Plugins are integrations that can provide MCP servers, skills, and capabilities.
+ *
+ * Features:
+ * - Lifecycle management with state machine
+ * - Security sandboxing and permission system
+ * - Dependency resolution and validation
+ * - Semantic version compatibility checking
+ * - Resource limits and quotas
+ * - Comprehensive observability with metrics
+ * - Graceful shutdown with retry logic
+ * - Plugin isolation with process spawning
+ *
+ * @version 1.1.0
+ */
+import { BaseIntegration, type IntegrationConfig, type HealthResult } from "../base/index.js";
+/**
+ * Plugin types matching the plugin architecture spec
+ */
+export declare enum PluginType {
+    MCP_SERVER = "mcp-server",
+    SKILL = "skill",
+    INTEGRATION = "integration",
+    AGENT = "agent"
+}
+/**
+ * Plugin lifecycle states
+ */
+export declare enum PluginState {
+    UNINSTALLED = "uninstalled",
+    INSTALLED = "installed",
+    ENABLED = "enabled",
+    ACTIVE = "active",
+    ERROR = "error",
+    DISABLING = "disabling",
+    ENABLING = "enabling"
+}
+/**
+ * Plugin configuration
+ */
+export interface PluginConfig extends IntegrationConfig {
+    type: PluginType;
+    autoStart: boolean;
+    config?: Record<string, unknown>;
+    resourceLimits?: PluginResourceLimits;
+    permissions?: PluginPermissions;
+}
+/**
+ * Resource limits for plugin
+ */
+export interface PluginResourceLimits {
+    maxMemoryMB?: number;
+    maxCpuPercent?: number;
+    maxProcessTime?: number;
+    maxFileDescriptors?: number;
+}
+/**
+ * Plugin permissions
+ */
+export interface PluginPermissions {
+    allowedPaths?: string[];
+    allowedCommands?: string[];
+    networkAccess?: boolean;
+    filesystemAccess?: boolean;
+    envWhitelist?: string[];
+}
+/**
+ * Plugin manifest (from plugin.yaml)
+ */
+export interface PluginManifest {
+    name: string;
+    version: string;
+    type: PluginType;
+    description: string;
+    license?: string | undefined;
+    author?: string | undefined;
+    homepage?: string | undefined;
+    repository?: string | undefined;
+    minStringrayVersion?: string | undefined;
+    runtime?: {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        timeout?: number | undefined;
+        workingDir?: string | undefined;
+    } | undefined;
+    tools?: Array<{
+        name: string;
+        description: string;
+        inputSchema?: object | undefined;
+        outputSchema?: object | undefined;
+    }> | undefined;
+    capabilities?: string[] | undefined;
+    dependencies?: Record<string, string> | undefined;
+    optionalDependencies?: Record<string, string> | undefined;
+    routing?: Array<{
+        keywords: string[];
+        skill: string;
+        agent: string;
+        confidence: number;
+    }> | undefined;
+    resourceLimits?: PluginResourceLimits | undefined;
+    permissions?: PluginPermissions | undefined;
+}
+/**
+ * Plugin routing mapping for enforcer
+ */
+export interface PluginRoutingMapping {
+    keywords: string[];
+    skill: string;
+    agent: string;
+    confidence: number;
+}
+/**
+ * Plugin metrics for observability
+ */
+export interface PluginMetrics {
+    name: string;
+    uptime: number;
+    totalRestarts: number;
+    lastStartTime: number;
+    lastError?: string | undefined;
+    memoryUsageMB?: number | undefined;
+    cpuUsagePercent?: number | undefined;
+    toolCallsCount: number;
+    errorsCount: number;
+}
+/**
+ * Validation result for plugin
+ */
+export interface PluginValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Default plugin configuration
+ */
+export declare const DEFAULT_PLUGIN_CONFIG: PluginConfig;
+/**
+ * Parse YAML manifest (shared utility)
+ */
+export declare function parseYamlManifest(content: string): Record<string, unknown>;
+/**
+ * Semantic version comparison
+ */
+export declare function satisfiesVersion(version: string, range: string): boolean;
+/**
+ * Validate plugin manifest
+ */
+export declare function validatePluginManifest(manifest: PluginManifest): PluginValidationResult;
+/**
+ * Plugin Integration Class
+ *
+ * Extends BaseIntegration to leverage existing:
+ * - Lifecycle management (initialize/shutdown)
+ * - Configuration handling
+ * - Event emission
+ * - Health checking
+ * - Logging
+ */
+export declare class PluginIntegration extends BaseIntegration {
+    private manifest;
+    private childProcess;
+    private pluginPath;
+    private pluginType;
+    private autoStart;
+    private pluginState;
+    private restarts;
+    private lastStartTime;
+    private lastError?;
+    private toolCallsCount;
+    private errorsCount;
+    private resourceLimits;
+    private permissions;
+    constructor(name: string, version: string, pluginPath: string, type?: PluginType, config?: Partial<PluginConfig>);
+    /**
+     * Load plugin from plugin.yaml
+     */
+    load(): Promise<PluginManifest>;
+    /**
+     * Initialize the plugin
+     */
+    protected performInitialization(): Promise<void>;
+    /**
+     * Shutdown the plugin
+     */
+    protected performShutdown(): Promise<void>;
+    /**
+     * Health check implementation
+     */
+    protected performHealthCheck(): Promise<HealthResult>;
+    /**
+     * Get plugin uptime in milliseconds
+     */
+    getUptime(): number;
+    /**
+     * Start the MCP server process
+     */
+    startPlugin(): Promise<void>;
+    /**
+     * Stop the MCP server process gracefully
+     */
+    stopPlugin(): Promise<void>;
+    /**
+     * Enable the plugin
+     */
+    enable(): Promise<void>;
+    /**
+     * Disable the plugin
+     */
+    disable(): Promise<void>;
+    /**
+     * Restart the plugin
+     */
+    restart(): Promise<void>;
+    /**
+     * Get MCP server configuration (if type is MCP_SERVER)
+     */
+    getMcpServerConfig(): {
+        serverName: string;
+        command: string;
+        args?: string[];
+        env?: Record<string, string>;
+        timeout?: number;
+    } | null;
+    /**
+     * Get tools provided by this plugin
+     */
+    getTools(): Array<{
+        name: string;
+        description: string;
+    }>;
+    /**
+     * Record a tool call
+     */
+    recordToolCall(): void;
+    /**
+     * Get capabilities
+     */
+    getCapabilities(): string[];
+    /**
+     * Get routing mappings for this plugin
+     */
+    getRoutingMappings(): PluginRoutingMapping[];
+    /**
+     * Set auto-start preference
+     */
+    setAutoStart(autoStart: boolean): void;
+    /**
+     * Get plugin type
+     */
+    getPluginType(): PluginType;
+    /**
+     * Get plugin state
+     */
+    getPluginState(): PluginState;
+    /**
+     * Get manifest
+     */
+    getManifest(): PluginManifest | null;
+    /**
+     * Check if plugin is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Get resource limits
+     */
+    getResourceLimits(): PluginResourceLimits;
+    /**
+     * Get permissions
+     */
+    getPermissions(): PluginPermissions;
+    /**
+     * Get comprehensive metrics
+     */
+    getMetrics(): PluginMetrics;
+    /**
+     * Get dependencies
+     */
+    getDependencies(): Record<string, string>;
+    /**
+     * Get optional dependencies
+     */
+    getOptionalDependencies(): Record<string, string>;
+}

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

@@ -0,0 +1,224 @@
+/**
+ * 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
+ *
+ * @version 1.1.0
+ */
+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/integrations/plugins/plugin-registry.js

@@ -46,8 +46,8 @@ export class PluginRegistry extends EventEmitter {
     reloadDebounce = new Map();
     constructor(config = {}) {
         super();
-        this.pluginsDir = config.pluginsDir || ".strray/plugins";
-        this.configPath = config.configPath || ".strray/config/plugin-config.json";
+        this.pluginsDir = config.pluginsDir || ".xray/plugins";
+        this.configPath = config.configPath || ".xray/config/plugin-config.json";
         this.autoStart = config.autoStart ?? true;
         this.enableMetrics = config.enableMetrics ?? true;
         this.enableHotReload = config.enableHotReload ?? false;

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

@@ -0,0 +1,46 @@
+/**
+ * Agent Resolver
+ *
+ * Resolves agent configurations from the 0xRay registry.
+ * Used by the integration layer to programmatically access agent configs.
+ *
+ * @version 1.1.0
+ * @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,17 @@
+/**
+ * 0xRay Architect Tools MCP Server
+ *
+ * Converts architect-tools.ts functions into MCP server tools
+ * Provides contextual analysis capabilities via MCP protocol
+ */
+declare class XrayArchitectToolsServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private contextAnalysis;
+    private codebaseStructure;
+    private dependencyAnalysis;
+    private architectureAssessment;
+    run(): Promise<void>;
+}
+export default XrayArchitectToolsServer;

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

@@ -9,11 +9,11 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { contextAnalysis as architectContextAnalysis, codebaseStructure as architectCodebaseStructure, dependencyAnalysis as architectDependencyAnalysis, architectureAssessment as architectArchitectureAssessment, } from "../architect/architect-tools.js";
-class StringRayArchitectToolsServer {
+class XrayArchitectToolsServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "architect-tools", version: "1.22.67",
+            name: "architect-tools", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -271,7 +271,7 @@ class StringRayArchitectToolsServer {
     }
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayArchitectToolsServer();
+    const server = new XrayArchitectToolsServer();
     server.run().catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
 }
-export default StringRayArchitectToolsServer;
+export default XrayArchitectToolsServer;

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

@@ -0,0 +1,19 @@
+/**
+ * 0xRay Auto Format MCP Server
+ *
+ * Automated code formatting hook with Prettier and framework-specific formatters
+ */
+declare class XrayAutoFormatServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private handleAutoFormat;
+    private handleFormatCheck;
+    private runPrettier;
+    private runEslintFix;
+    private runTypeScriptFormat;
+    private checkFormatting;
+    private generateFormatSummary;
+    run(): Promise<void>;
+}
+export { XrayAutoFormatServer };

package/dist/mcps/auto-format.server.js

@@ -9,11 +9,11 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextpro
 import { execFileSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
-class StringRayAutoFormatServer {
+class XrayAutoFormatServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "auto-format", version: "1.22.67",
+            name: "auto-format", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -407,7 +407,7 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const server = new StringRayAutoFormatServer();
+    const server = new XrayAutoFormatServer();
     server.run().catch((error) => frameworkLogger.log("mcps/auto-format", "run", "error", { error: String(error) }));
 }
-export { StringRayAutoFormatServer };
+export { XrayAutoFormatServer };

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

@@ -0,0 +1,49 @@
+/**
+ * 0xRay Boot Orchestrator MCP Server
+ *
+ * Advanced initialization orchestration with dependency management and health monitoring
+ */
+declare class XrayBootOrchestratorServer {
+    private server;
+    private bootStatus;
+    private bootSequence;
+    constructor();
+    private initializeDependencies;
+    private setupToolHandlers;
+    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;
+    run(): Promise<void>;
+}
+export { XrayBootOrchestratorServer };