0xray 3.4.2 → 3.4.3

package/dist/mcps/processor-pipeline.server.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 0xRay Processor Pipeline MCP Server
+ *
+ * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
+    private codexLoader;
+    private codexRules;
+    private codexTerms;
+    constructor();
+    private loadCodexRules;
+    private handlePreProcessors;
+    private handlePostProcessors;
+    private handleCodexValidation;
+    private handleComplianceCheck;
+    private sanitizeInput;
+    private validateAgainstCodex;
+    private checkCodexTerm;
+    private enrichWithContext;
+    private performSecurityChecks;
+    private validateResults;
+    private enforceCompliance;
+    private generateAuditTrail;
+    private performQualityAssurance;
+    private detectContentType;
+    private checkFrameworkCompliance;
+}
+export { XrayProcessorPipelineServer };

package/dist/mcps/protocol/protocol-constants.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Protocol Constants
+ *
+ * MCP protocol constants and configuration values.
+ * Extracted to enable reuse and single source of truth.
+ */
+/**
+ * MCP Protocol Version
+ * Current MCP protocol specification version
+ */
+export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
+/**
+ * JSON-RPC Protocol Version
+ * Standard JSON-RPC version used by MCP
+ */
+export declare const JSONRPC_VERSION = "2.0";
+/**
+ * MCP Method Names
+ * Standard MCP protocol method identifiers
+ */
+export declare const MCP_METHODS: {
+    readonly INITIALIZE: "initialize";
+    readonly TOOLS_LIST: "tools/list";
+    readonly TOOLS_CALL: "tools/call";
+};
+/**
+ * Default Timeout Values
+ * Millisecond timeouts for various MCP operations
+ */
+export declare const DEFAULT_TIMEOUTS: {
+    readonly CONNECTION: 30000;
+    readonly REQUEST: 60000;
+    readonly INITIALIZATION: 10000;
+};
+/**
+ * Error Codes
+ * Standard JSON-RPC error codes used by MCP
+ */
+export declare const ERROR_CODES: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    readonly SERVER_ERROR: -32000;
+};

package/dist/mcps/researcher-confidence.d.ts

@@ -0,0 +1,21 @@
+import type { MemoryRoutingContext, MemoryTaskConfidence } from '../memory-routing/types.js';
+export interface ResearcherMemoryContext {
+    providerId: string;
+    confidence: MemoryTaskConfidence;
+    matchedSignals: string[];
+    recommendedAgent: string | null;
+    triggeredBy: 'trap-language' | 'high-confidence-primitives';
+}
+export declare function shouldQueryRepertoireConfidence(description: string, proposalType?: string): boolean;
+export declare function hasHighConfidencePrimitiveMatch(routingContext: MemoryRoutingContext, minConfidence?: number): boolean;
+/**
+ * Resolve Repertoire task confidence for researcher proposal analysis.
+ * Triggered by ontological-trap language or high-confidence primitive matches.
+ */
+export declare function resolveResearcherMemoryContext(input: {
+    proposalTitle?: string;
+    proposalDescription?: string;
+    proposalType?: string;
+}): ResearcherMemoryContext | null;
+export declare function buildMemoryRoutingEvidence(context: ResearcherMemoryContext): string[];
+export declare function formatMemoryRoutingBlock(context: ResearcherMemoryContext): string;

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

@@ -0,0 +1,29 @@
+/**
+ * 0xRay Librarian MCP Server
+ *
+ * Knowledge skill for codebase documentation lookup, implementation examples,
+ * and multi-repo analysis - serves as the universal documentation reference
+ *
+ * NOTE: Class is named XrayLibrarianServer but the MCP server name is
+ * "researcher" for backwards compatibility with existing tool references.
+ */
+import { type CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+interface AnalyzeProposalArgs {
+    proposalTitle?: string;
+    proposalDescription?: string;
+    evidence?: string[];
+    proposalType?: string;
+}
+declare class XrayLibrarianServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private searchCodebase;
+    private findImplementation;
+    private getDocumentation;
+    /**
+     * Governance-oriented proposal analysis from the researcher / librarian perspective.
+     * Uses corpus patterns, historical recurrence, and architecture knowledge.
+     */
+    analyzeProposal(args: AnalyzeProposalArgs): Promise<CallToolResult>;
+}
+export { XrayLibrarianServer };

package/dist/mcps/security-scan.server.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 0xRay Security Scan MCP Server
+ *
+ * Automated security vulnerability scanning with dependency and code analysis
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XraySecurityScanServer extends XrayKnowledgeSkillBase {
+    constructor();
+    protected setupToolHandlers(): void;
+    private handleSecurityScan;
+    private handleDependencyAudit;
+    private detectPackageManager;
+    private scanDependencies;
+    private scanCodeSecurity;
+    private findCodeFiles;
+    private analyzeFileForSecurity;
+    private generateSecuritySummary;
+}
+export { XraySecurityScanServer };

package/dist/mcps/shared/knowledge-skill-base.d.ts

@@ -0,0 +1,17 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: object;
+}
+export declare class XrayKnowledgeSkillBase {
+    protected tools: ToolDefinition[];
+    protected handlers: Record<string, (args: unknown) => Promise<any>>;
+    protected server: Server;
+    protected serverName: string;
+    constructor(serverName: string, version?: string);
+    protected setupToolHandlers(): void;
+    protected setupListToolsHandler(): void;
+    protected setupCallToolHandler(): void;
+    run(): Promise<void>;
+}

package/dist/mcps/shared/prompt-security-validator.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 0xRay Framework - AI Prompt Security Validator
+ *
+ * Specialized security validation for AI agent prompts and responses
+ * Prevents prompt injection, system prompt override, and malicious inputs
+ */
+export interface PromptSecurityConfig {
+    enabled: boolean;
+    maxPromptLength: number;
+    allowedPatterns: RegExp[];
+    blockedPatterns: RegExp[];
+    sanitizeLevel: "basic" | "strict" | "paranoid";
+}
+export interface SecurityValidationResult {
+    isSafe: boolean;
+    violations: string[];
+    sanitizedPrompt?: string | undefined;
+    riskLevel: "low" | "medium" | "high" | "critical";
+}
+export declare class PromptSecurityValidator {
+    private config;
+    constructor(config?: Partial<PromptSecurityConfig>);
+    /**
+     * Validate AI prompt for security issues
+     */
+    validatePrompt(prompt: string): SecurityValidationResult;
+    /**
+     * Check for system prompt override attempts
+     */
+    private containsSystemPromptOverride;
+    /**
+     * Check for prompt injection attempts
+     */
+    private containsInjectionAttempts;
+    /**
+     * Sanitize prompt by removing dangerous patterns
+     */
+    private sanitizePrompt;
+    /**
+     * Validate agent response for safety
+     */
+    validateResponse(response: string): SecurityValidationResult;
+}
+export declare const promptSecurityValidator: PromptSecurityValidator;

package/dist/mcps/shared/security-scanner.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 0xRay Framework - Security Scanner
+ *
+ * Automated security vulnerability scanning and compliance validation
+ * Integrates with security tools and provides comprehensive security reports
+ */
+export interface SecurityScanConfig {
+    enabled: boolean;
+    tools: {
+        npmAudit: boolean;
+        trivy: boolean;
+        eslintSecurity: boolean;
+        dependencyCheck: boolean;
+    };
+    severityThreshold: "low" | "moderate" | "high" | "critical";
+    reportPath: string;
+    failOnVulnerabilities: boolean;
+}
+export interface SecurityVulnerability {
+    id: string;
+    title: string;
+    description: string;
+    severity: "low" | "moderate" | "high" | "critical";
+    package?: string;
+    version?: string;
+    cve?: string;
+    url?: string;
+    recommendation: string;
+}
+export interface SecurityReport {
+    timestamp: string;
+    duration: number;
+    tools: {
+        npmAudit: SecurityVulnerability[];
+        trivy: SecurityVulnerability[];
+        eslintSecurity: SecurityVulnerability[];
+        dependencyCheck: SecurityVulnerability[];
+    };
+    summary: {
+        totalVulnerabilities: number;
+        bySeverity: Record<string, number>;
+        byTool: Record<string, number>;
+    };
+    recommendations: string[];
+    compliant: boolean;
+}
+export declare class SecurityScanner {
+    private config;
+    constructor(config?: Partial<SecurityScanConfig>);
+    /**
+     * Run comprehensive security scan
+     */
+    runSecurityScan(): Promise<SecurityReport>;
+    /**
+     * Run npm audit
+     */
+    private runNpmAudit;
+    /**
+     * Run Trivy security scan
+     */
+    private runTrivyScan;
+    /**
+     * Run ESLint security rules
+     */
+    private runEslintSecurity;
+    /**
+     * Run OWASP Dependency Check
+     */
+    private runDependencyCheck;
+    /**
+     * Generate comprehensive security report
+     */
+    private generateReport;
+    /**
+     * Generate security recommendations
+     */
+    private generateRecommendations;
+    /**
+     * Save report to file
+     */
+    private saveReport;
+    /**
+     * Log security scan results
+     */
+    private logResults;
+    /**
+     * Map npm audit severity levels
+     */
+    private mapNpmSeverity;
+    /**
+     * Map Trivy severity levels
+     */
+    private mapTrivySeverity;
+    /**
+     * Map Dependency Check severity levels
+     */
+    private mapDependencyCheckSeverity;
+    /**
+     * Validate AI prompt security
+     */
+    validatePrompt(prompt: string): Promise<{
+        isSafe: boolean;
+        violations: string[];
+        riskLevel: string;
+    }>;
+    /**
+     * Validate AI response security
+     */
+    validateResponse(response: string): Promise<{
+        isSafe: boolean;
+        violations: string[];
+        riskLevel: string;
+    }>;
+    /**
+     * Create empty report when scanning is disabled
+     */
+    private createEmptyReport;
+}
+export declare const securityScanner: SecurityScanner;

package/dist/mcps/simulation/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Simulation Module Barrel Export
+ *
+ * Centralized export for all MCP simulation functionality.
+ *
+ * @example
+ * ```typescript
+ * import { SimulationEngine, getAllServerSimulations } from './simulation/index.js';
+ * ```
+ */
+export { SimulationEngine, type SimulatorFunction } from './simulation-engine.js';
+export { getAllServerSimulations, codeReviewSimulations, securityAuditSimulations, performanceOptimizationSimulations, testingStrategySimulations, researcherSimulations, frameworkHelpSimulations, skillInvocationSimulations, type ServerSimulations, } from './server-simulations.js';

package/dist/mcps/simulation/server-simulations.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Server Simulations
+ *
+ * Pre-built simulation implementations for all MCP servers.
+ * Extracted from mcp-client.ts as part of Phase 5 refactoring.
+ */
+import { SimulatorFunction } from './simulation-engine.js';
+export interface ServerSimulations {
+    [serverName: string]: Record<string, SimulatorFunction>;
+}
+/**
+ * Code Review server simulations
+ */
+export declare const codeReviewSimulations: Record<string, SimulatorFunction>;
+/**
+ * Security Audit server simulations
+ */
+export declare const securityAuditSimulations: Record<string, SimulatorFunction>;
+/**
+ * Performance Optimization server simulations
+ */
+export declare const performanceOptimizationSimulations: Record<string, SimulatorFunction>;
+/**
+ * Testing Strategy server simulations
+ */
+export declare const testingStrategySimulations: Record<string, SimulatorFunction>;
+/**
+ * Researcher server simulations
+ */
+export declare const researcherSimulations: Record<string, SimulatorFunction>;
+/**
+ * Framework Help server simulations
+ */
+export declare const frameworkHelpSimulations: Record<string, SimulatorFunction>;
+/**
+ * Skill Invocation server simulations
+ */
+export declare const skillInvocationSimulations: Record<string, SimulatorFunction>;
+export declare function getAllServerSimulations(): ServerSimulations;

package/dist/mcps/simulation/simulation-engine.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Simulation Engine
+ *
+ * Provides fallback simulation for MCP tools when real servers are unavailable.
+ * Part of Phase 5 refactoring - Simulation Layer extraction.
+ */
+import { MCPToolResult, ISimulationEngine } from '../types/index.js';
+export type SimulatorFunction = (args: unknown) => MCPToolResult | Promise<MCPToolResult>;
+export declare class SimulationEngine implements ISimulationEngine {
+    private simulators;
+    /**
+     * Register a simulator for a specific server and tool
+     */
+    registerSimulator(serverName: string, toolName: string, simulator: SimulatorFunction): void;
+    /**
+     * Register multiple simulators for a server
+     */
+    registerServerSimulators(serverName: string, simulators: Record<string, SimulatorFunction>): void;
+    /**
+     * Check if a simulator exists for a server/tool combination
+     */
+    canSimulate(serverName: string, toolName: string): boolean;
+    /**
+     * Execute a simulation
+     */
+    simulate(serverName: string, toolName: string, args: unknown): Promise<MCPToolResult>;
+    /**
+     * Get all registered simulator names for a server
+     */
+    getServerTools(serverName: string): string[];
+    /**
+     * Get all registered server names
+     */
+    getRegisteredServers(): string[];
+    /**
+     * Unregister a specific simulator
+     */
+    unregisterSimulator(serverName: string, toolName: string): boolean;
+    /**
+     * Unregister all simulators for a server
+     */
+    unregisterServer(serverName: string): boolean;
+    /**
+     * Clear all registered simulators
+     */
+    clear(): void;
+    /**
+     * Get total count of registered simulators
+     */
+    getSimulatorCount(): number;
+}

package/dist/mcps/state-manager.server.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 0xRay State Manager MCP Server
+ *
+ * Advanced state management with persistence, synchronization, and conflict resolution
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayStateManagerServer extends XrayKnowledgeSkillBase {
+    private state;
+    private stateFile;
+    private backups;
+    constructor();
+    private ensureStateDirectory;
+    private loadState;
+    private saveState;
+    setupToolHandlers(): void;
+    private handleGetState;
+    private handleSetState;
+    private handleDeleteState;
+    private handleListState;
+    private handleBackupState;
+    private handleRestoreState;
+    private handleValidateState;
+    private validateStateValue;
+    private repairStateValue;
+    private findDependentKeys;
+}
+export { XrayStateManagerServer };

package/dist/mcps/tools/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tools Module Barrel Export
+ *
+ * Centralized export for all MCP tool management functionality.
+ *
+ * @example
+ * ```typescript
+ * import { ToolRegistry, ToolDiscovery, ToolExecutor, ToolCache } from './tools/index.js';
+ * ```
+ */
+export { ToolRegistry } from './tool-registry.js';
+export { ToolDiscovery } from './tool-discovery.js';
+export { ToolExecutor } from './tool-executor.js';
+export { ToolCache, type ToolCacheOptions } from './tool-cache.js';

package/dist/mcps/tools/tool-cache.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Tool Cache
+ *
+ * Caches discovered tools to reduce network round-trips.
+ * Part of Phase 4 refactoring - Tool Layer extraction.
+ */
+import { MCPTool } from '../types/index.js';
+export interface ToolCacheOptions {
+    ttlMs?: number;
+    maxEntries?: number;
+}
+export declare class ToolCache {
+    private cache;
+    private readonly ttlMs;
+    private readonly maxEntries;
+    private accessOrder;
+    constructor(options?: ToolCacheOptions);
+    /**
+     * Get cached tools for a server
+     */
+    get(serverName: string): MCPTool[] | null;
+    /**
+     * Cache tools for a server
+     */
+    set(serverName: string, tools: MCPTool[]): void;
+    /**
+     * Clear all cached entries
+     */
+    clear(): void;
+    /**
+     * Remove cached tools for a specific server
+     */
+    invalidate(serverName: string): boolean;
+    /**
+     * Check if tools are cached for a server
+     */
+    has(serverName: string): boolean;
+    /**
+     * Get all cached server names
+     */
+    getCachedServers(): string[];
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        maxEntries: number;
+        ttlMs: number;
+    };
+    private updateAccessOrder;
+    private removeFromAccessOrder;
+    private evictOldest;
+}

package/dist/mcps/tools/tool-discovery.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Tool Discovery
+ *
+ * Handles dynamic tool discovery from MCP servers via JSON-RPC protocol.
+ * Part of Phase 4 refactoring - Tool Layer extraction.
+ */
+import { MCPTool, IMcpConnection } from '../types/index.js';
+import { JsonRpcRequest, JsonRpcResponse } from '../types/index.js';
+export declare class ToolDiscovery {
+    /**
+     * Discover available tools from an MCP server connection
+     */
+    discoverTools(connection: IMcpConnection): Promise<MCPTool[]>;
+    /**
+     * Build a tool list request for JSON-RPC
+     */
+    buildToolListRequest(requestId?: number): JsonRpcRequest;
+    /**
+     * Parse tools from a JSON-RPC response
+     */
+    parseTools(response: JsonRpcResponse): MCPTool[];
+    /**
+     * Validate that discovered tools have required fields
+     */
+    validateTools(tools: unknown[]): MCPTool[];
+    private isValidTool;
+}

package/dist/mcps/tools/tool-executor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Tool Executor
+ *
+ * Handles tool execution via JSON-RPC protocol.
+ * Part of Phase 4 refactoring - Tool Layer extraction.
+ */
+import { MCPToolResult, IMcpConnection } from '../types/index.js';
+import { JsonRpcRequest, JsonRpcResponse } from '../types/index.js';
+export declare class ToolExecutor {
+    private requestId;
+    /**
+     * Execute a tool on an MCP server
+     */
+    executeTool(connection: IMcpConnection, toolName: string, args: unknown): Promise<MCPToolResult>;
+    /**
+     * Build a tool call request for JSON-RPC
+     */
+    buildToolCallRequest(toolName: string, args: unknown, requestId?: number): JsonRpcRequest;
+    /**
+     * Parse a tool result from JSON-RPC response
+     */
+    parseToolResult(response: JsonRpcResponse): MCPToolResult;
+    /**
+     * Execute multiple tools in sequence
+     */
+    executeTools(connection: IMcpConnection, executions: Array<{
+        toolName: string;
+        args: unknown;
+    }>): Promise<MCPToolResult[]>;
+    /**
+     * Execute multiple tools in parallel
+     */
+    executeToolsParallel(connection: IMcpConnection, executions: Array<{
+        toolName: string;
+        args: unknown;
+    }>): Promise<MCPToolResult[]>;
+    /**
+     * Reset the request ID counter
+     */
+    resetRequestId(): void;
+}

package/dist/mcps/tools/tool-registry.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Tool Registry
+ *
+ * Manages tool registration and lookup across MCP servers.
+ * Part of Phase 4 refactoring - Tool Layer extraction.
+ */
+import { MCPTool, IToolRegistry } from '../types/index.js';
+export declare class ToolRegistry implements IToolRegistry {
+    private tools;
+    /**
+     * Register tools for a specific server
+     */
+    register(serverName: string, tools: MCPTool[]): void;
+    /**
+     * Get a specific tool by server and tool name
+     */
+    getTool(serverName: string, toolName: string): MCPTool | undefined;
+    /**
+     * Get all tools for a specific server
+     */
+    getTools(serverName: string): MCPTool[];
+    /**
+     * Check if a tool exists
+     */
+    hasTool(serverName: string, toolName: string): boolean;
+    /**
+     * Clear all registered tools
+     */
+    clear(): void;
+    /**
+     * Get all registered server names
+     */
+    getServerNames(): string[];
+    /**
+     * Remove all tools for a specific server
+     */
+    unregisterServer(serverName: string): boolean;
+    /**
+     * Get total tool count across all servers
+     */
+    getToolCount(): number;
+}

package/dist/mcps/types/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MCP Types Barrel Export
+ *
+ * Centralized export for all MCP-related types.
+ * Import from this file to access all MCP types.
+ *
+ * @example
+ * ```typescript
+ * import { MCPClientConfig, MCPTool, JsonRpcRequest } from './types/index.js';
+ * ```
+ */
+export * from './mcp.types.js';
+export * from './json-rpc.types.js';