0xray 3.4.2 → 3.4.4

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,26 @@
+/**
+ * 0xRay Enforcer Tools MCP Server
+ *
+ * Converts enforcer-tools.ts functions into MCP server tools
+ * Provides rule enforcement and validation capabilities via MCP protocol
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayEnforcerToolsServer extends XrayKnowledgeSkillBase {
+    constructor();
+    setupToolHandlers(): void;
+    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;
+    private securityScan;
+}
+export default XrayEnforcerToolsServer;

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

@@ -0,0 +1,19 @@
+/**
+ * Estimation MCP Server
+ *
+ * Provides tools for tracking and validating estimates
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+/**
+ * Estimation MCP Server
+ * Tracks estimates vs actuals and provides calibrated predictions
+ */
+declare class EstimationServer extends XrayKnowledgeSkillBase {
+    private validator;
+    constructor();
+    private handleValidateEstimate;
+    private handleStartTracking;
+    private handleCompleteTracking;
+    private handleGetReport;
+}
+export { EstimationServer };

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

@@ -0,0 +1,20 @@
+/**
+ * 0xRay Framework Compliance Audit MCP Server
+ *
+ * Comprehensive validation of all framework components and Universal Development Codex compliance
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayFrameworkComplianceAuditServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private handleFrameworkComplianceAudit;
+    private handleCodexValidation;
+    private auditConfigurationIntegrity;
+    private auditAgentConfigurations;
+    private auditCodexCompliance;
+    private auditPerformanceThresholds;
+    private validateCodexTerms;
+    private checkTermImplementation;
+    private generateAuditSummary;
+    private getDetailedFindings;
+}
+export { XrayFrameworkComplianceAuditServer };

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

@@ -0,0 +1,13 @@
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class FrameworkHelpServer extends XrayKnowledgeSkillBase {
+    constructor();
+    setupToolHandlers(): void;
+    private getActiveAgentEntries;
+    private handleGetCapabilities;
+    private handleGetCommands;
+    private handleExplainCapability;
+    private generateCommandList;
+    private generateFullCapabilities;
+    private generateCategoryCapabilities;
+}
+export { FrameworkHelpServer };

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

@@ -0,0 +1,35 @@
+/**
+ * 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";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class GovernanceServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private validateGovernProposalsArgs;
+    private validateGovernReflectionArgs;
+    protected setupToolHandlers(): void;
+    /** Align tool default with features.json inference_governance.enabled (P0.2). */
+    private resolveRequireExternal;
+    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/governance.server.js

@@ -16,13 +16,13 @@ import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js
 import { CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { featuresConfigLoader } from "../core/features-config.js";
 import * as fs from "fs";
 import { fileURLToPath } from "url";
 import { randomUUID } from "crypto";
 import { getGovernanceService } from "../governance/governance-service.js";
 import { getCodexPolicyService } from "../governance/codex-policy.service.js";
 import { initializeGovernanceIntegration } from "../integrations/governance/index.js";
-import { featuresConfigLoader } from "../core/features-config.js";
 class GovernanceServer extends XrayKnowledgeSkillBase {
     constructor() {
         super("governance", "3.1.0");
@@ -184,6 +184,18 @@ class GovernanceServer extends XrayKnowledgeSkillBase {
             }
         });
     }
+    /** Align tool default with features.json inference_governance.enabled (P0.2). */
+    resolveRequireExternal(explicit) {
+        if (explicit !== undefined)
+            return explicit;
+        try {
+            const config = featuresConfigLoader.loadConfig();
+            return config?.inference_governance?.enabled === true;
+        }
+        catch {
+            return false;
+        }
+    }
     async handleGovernProposals(args) {
         const service = getGovernanceService();
         const request = {
@@ -198,7 +210,7 @@ class GovernanceServer extends XrayKnowledgeSkillBase {
             })),
             context: args.context || {},
             options: {
-                requireExternalDynamo: args.options?.require_external ?? true,
+                requireExternalDynamo: this.resolveRequireExternal(args.options?.require_external),
             },
         };
         frameworkLogger.log("governance-mcp", "delegating-to-governance-service", "info", {

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 };

package/dist/mcps/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * xray MCP Server Manifest
+ *
+ * Canonical registry of all MCP servers. Add new servers here.
+ * Each entry documents the server name, source file, and server type.
+ */
+export interface McpServerEntry {
+    serverName: string;
+    sourceFile: string;
+    type: "top-level" | "knowledge-skill" | "orchestrator";
+    registered: boolean;
+    description: string;
+}
+export declare const MCP_SERVERS: McpServerEntry[];
+export declare function getMcpServer(serverName: string): McpServerEntry | undefined;
+export declare function getRegisteredServers(): McpServerEntry[];
+export declare function getUnregisteredServers(): McpServerEntry[];

package/dist/mcps/knowledge-skills/api-design.server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * xray API Design MCP Server
+ *
+ * Knowledge skill for API design patterns, RESTful conventions,
+ * GraphQL schema design, and API documentation standards
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayApiDesignServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private designApiEndpoints;
+    private validateApiDesign;
+}
+export default XrayApiDesignServer;

package/dist/mcps/knowledge-skills/architecture-patterns.server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * xray Architecture Patterns MCP Server
+ *
+ * Knowledge skill for architectural pattern recognition,
+ * design pattern recommendations, and system architecture guidance
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayArchitecturePatternsServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private analyzeArchitecture;
+    private recommendPatterns;
+}
+export default XrayArchitecturePatternsServer;

package/dist/mcps/knowledge-skills/bug-triage-specialist.server.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Bug Triage Specialist MCP Server
+ *
+ * Comprehensive bug triage, debugging analysis, and issue prioritization.
+ * Provides automated root cause analysis, stack trace interpretation,
+ * and actionable debugging recommendations.
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class BugTriageSpecialistServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private triageBugs;
+    private analyzeStackTrace;
+    private suggestFixes;
+    private prioritizeIssues;
+    private findRelatedIssues;
+    private estimateSeverity;
+    private categorizeBug;
+    private extractTitle;
+    private extractErrorMessage;
+    private extractStackTrace;
+    private determineRootCause;
+    private assessImpact;
+    private estimateFixComplexity;
+    private generateRecommendations;
+    private findRelatedFiles;
+    private generateFixCode;
+    private suggestFixFromTrace;
+    private calculatePriorityScore;
+    private estimateEffort;
+}
+export { BugTriageSpecialistServer };

package/dist/mcps/knowledge-skills/code-analyzer.server.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Code Analyzer MCP Server - CONSOLIDATED
+ *
+ * Comprehensive code analysis combining:
+ * - Original code-analyzer (metrics, complexity, smells)
+ * - explore (file search, patterns, dependencies)
+ * - analyzer (pattern detection)
+ *
+ * This is the SINGLE source for code-level analysis.
+ * Use project-analysis for project-level (structure, health).
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class CodeAnalyzerServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private handleAnalyzeCode;
+    private calculateCodeMetrics;
+    private calculateCyclomaticComplexity;
+    private handleCalculateComplexity;
+    private handleDetectCodeSmells;
+    private handleExtractMetrics;
+    private handleExploreCodebase;
+    private matchesPattern;
+    private handleFindPatterns;
+    private handleFindFunction;
+    private handleGetFileStructure;
+    private handleAnalyzeDependencies;
+    private handleFindDuplicates;
+}
+export default CodeAnalyzerServer;

package/dist/mcps/knowledge-skills/code-review.server.d.ts

@@ -0,0 +1,44 @@
+/**
+ * xray Code Review MCP Server
+ *
+ * Knowledge skill for automated code review, quality assessment,
+ * and best practices validation - provides comprehensive code quality analysis
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+interface AnalyzeProposalArgs {
+    proposalTitle?: string;
+    proposalDescription?: string;
+    evidence?: string[];
+    proposalType?: string;
+}
+declare class XrayCodeReviewServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private analyzeCodeQuality;
+    private reviewPullRequest;
+    private checkBestPractices;
+    private detectLanguage;
+    /**
+     * Governance-oriented proposal analysis from a code quality perspective.
+     */
+    analyzeProposal(args: AnalyzeProposalArgs): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    private analyzeCode;
+    private analyzeSecurity;
+    private analyzePerformance;
+    private analyzeMaintainability;
+    private analyzeStyle;
+    private analyzeLogic;
+    private calculateMetrics;
+    private calculateDuplicateLines;
+    private generateSuggestions;
+    private calculateOverallScore;
+    private assessOverallQuality;
+    private checkStandardsCompliance;
+    private generateStandardsRecommendations;
+    private calculateComplianceScore;
+}
+export { XrayCodeReviewServer };

package/dist/mcps/knowledge-skills/content-creator.server.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SEO Copywriter MCP Server
+ *
+ * Content-focused SEO for both human readers and AI search engines.
+ * Provides keyword optimization, meta descriptions, headlines, and conversion copy.
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class SEOCopywriterServer extends XrayKnowledgeSkillBase {
+    constructor();
+}
+export { SEOCopywriterServer };

package/dist/mcps/knowledge-skills/database-design.server.d.ts

@@ -0,0 +1,41 @@
+/**
+ * xray Database Design MCP Server
+ *
+ * Knowledge skill for database architecture, schema optimization,
+ * query performance analysis, and data modeling best practices
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayDatabaseDesignServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private analyzeSchema;
+    private optimizeQuery;
+    private designDataModel;
+    private migrateSchema;
+    private parseSchema;
+    private parseSchemaString;
+    private parseTableColumns;
+    private extractPrimaryKey;
+    private extractRelationships;
+    private analyzeSchemaDesign;
+    private assessNormalization;
+    private evaluateIndexing;
+    private assessRelationshipComplexity;
+    private identifyPerformanceIssues;
+    private generateIndexRecommendations;
+    private identifySchemaIssues;
+    private generateSchemaRecommendations;
+    private calculateNormalizationScore;
+    private calculateIndexingCoverage;
+    private analyzeQuery;
+    private generateQueryOptimizations;
+    private calculateQueryPerformanceScore;
+    private generateDataModel;
+    private validateDataModel;
+    private generateModelRecommendations;
+    private compareSchemas;
+    private generateMigrationScript;
+    private generateRollbackScript;
+    private toTableName;
+    private getIssueSeverityIcon;
+}
+export { XrayDatabaseDesignServer };

package/dist/mcps/knowledge-skills/devops-deployment.server.d.ts

@@ -0,0 +1,41 @@
+/**
+ * xray DevOps Deployment MCP Server
+ *
+ * Knowledge skill for DevOps practices, deployment strategies,
+ * CI/CD pipeline design, and infrastructure automation
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayDevOpsDeploymentServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private analyzeCICDPipeline;
+    private designDeploymentStrategy;
+    private generateInfrastructureCode;
+    private optimizeDeploymentPerformance;
+    private parsePipelineConfig;
+    private analyzePipelineStructure;
+    private generatePipelineOptimizations;
+    private analyzePipelineSecurity;
+    private calculatePipelineScore;
+    private generateDeploymentStrategies;
+    private selectOptimalStrategy;
+    private generateStrategyImplementation;
+    private analyzeInfrastructureNeeds;
+    private generateInfrastructureAsCode;
+    private generateTerraformAWS;
+    private generateKubernetesYAML;
+    private generateMonitoringConfiguration;
+    private generateSecurityConfiguration;
+    private analyzeDeploymentMetrics;
+    private identifyDeploymentBottlenecks;
+    private generateDeploymentOptimizations;
+    private createOptimizationRoadmap;
+    private calculateDeploymentEfficiency;
+    private calculateDeploymentReliability;
+    private calculateDeploymentSpeed;
+    private identifyMetricBottlenecks;
+    private calculateDependencyComplexity;
+    private analyzeStageDistribution;
+    private identifyPipelineOptimizations;
+    private getInfrastructureLanguage;
+}
+export { XrayDevOpsDeploymentServer };

package/dist/mcps/knowledge-skills/git-workflow.server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * xray Git Workflow MCP Server
+ *
+ * Knowledge skill for version control strategies, branching models,
+ * and collaborative development workflows
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayGitWorkflowServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private analyzeGitHistory;
+    private recommendBranchingStrategy;
+}
+export default XrayGitWorkflowServer;

package/dist/mcps/knowledge-skills/growth-strategist.server.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Marketing Expert MCP Server
+ *
+ * Strategic marketing for campaign strategy, market analysis, and conversion optimization.
+ * Implements "Don't Make Me Think" principles for high-converting landing pages.
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class MarketingExpertServer extends XrayKnowledgeSkillBase {
+    constructor();
+}
+export { MarketingExpertServer };

package/dist/mcps/knowledge-skills/log-monitor.server.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Log Monitor MCP Server
+ *
+ * Comprehensive log analysis, pattern detection, and alerting system.
+ * Monitors application logs for errors, anomalies, security threats,
+ * and performance issues in real-time.
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class LogMonitorServer extends XrayKnowledgeSkillBase {
+    private patternLibrary;
+    constructor();
+    private analyzeLogs;
+    private detectPatterns;
+    private alertOnIssues;
+    private correlateEvents;
+    private generateReport;
+    private parseLogEntry;
+    private detectPatternsInLogs;
+    private detectAnomalies;
+    private generateRecommendations;
+}
+export { LogMonitorServer };

package/dist/mcps/knowledge-skills/mobile-development.server.d.ts

@@ -0,0 +1,17 @@
+/**
+ * xray Mobile Development MCP Server
+ *
+ * Knowledge skill for mobile app development including iOS, Android,
+ * React Native, Flutter, and mobile performance optimization
+ */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayMobileDevelopmentServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private generateIOSBlueprint;
+    private generateAndroidBlueprint;
+    private generateReactNativeBlueprint;
+    private generateFlutterBlueprint;
+    private analyzeMobilePerformance;
+    private generateAppStoreMetadata;
+}
+export { XrayMobileDevelopmentServer };