0xray 2.0.0

package/dist/mcps/processor-pipeline.server.js

@@ -0,0 +1,561 @@
+/**
+ * 0xRay Processor Pipeline MCP Server
+ *
+ * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { CodexLoader } from "../enforcement/loaders/codex-loader.js";
+class StringRayProcessorPipelineServer {
+    server;
+    codexLoader;
+    codexRules = [];
+    codexTerms = [
+        "Progressive Prod-Ready Code",
+        "No Stubs/Patches",
+        "Surgical Fixes",
+        "Type Safety First",
+        "Single Source of Truth",
+        "Error Boundaries",
+        "Performance Budget Enforcement",
+        "Security by Design",
+        "Test Coverage >85%",
+    ];
+    constructor() {
+        this.codexLoader = new CodexLoader();
+        this.server = new Server({
+            name: "processor-pipeline", version: "1.22.67",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupToolHandlers();
+        this.loadCodexRules();
+        // Server initialized silently - use frameworkLogger for important events
+    }
+    async loadCodexRules() {
+        try {
+            if (await this.codexLoader.isAvailable()) {
+                this.codexRules = await this.codexLoader.load();
+                await frameworkLogger.log("mcps/processor-pipeline", "codex-rules-loaded", "success", { message: `Loaded ${this.codexRules.length} codex rules for MCP validation` });
+            }
+        }
+        catch (error) {
+            await frameworkLogger.log("mcps/processor-pipeline", "codex-rules-load-failed", "warning", { message: `Failed to load codex rules: ${error instanceof Error ? error.message : String(error)}` });
+        }
+    }
+    setupToolHandlers() {
+        // List available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "execute-pre-processors",
+                        description: "Run pre-execution processors on content with codex validation",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                content: { type: "string" },
+                                context: { type: "object" },
+                                validateCodex: { type: "boolean", default: true },
+                                strictMode: { type: "boolean", default: false },
+                            },
+                            required: ["content"],
+                        },
+                    },
+                    {
+                        name: "execute-post-processors",
+                        description: "Run post-execution processors on results with compliance monitoring",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                content: { type: "string" },
+                                results: { type: "object" },
+                                enforceCompliance: { type: "boolean", default: true },
+                                auditTrail: { type: "boolean", default: true },
+                            },
+                            required: ["content"],
+                        },
+                    },
+                    {
+                        name: "codex-validation",
+                        description: "Validate content against Universal Development Codex terms",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                content: { type: "string" },
+                                terms: {
+                                    type: "array",
+                                    items: { type: "string" },
+                                    default: ["all"],
+                                },
+                                strict: { type: "boolean", default: false },
+                            },
+                            required: ["content"],
+                        },
+                    },
+                    {
+                        name: "framework-compliance-check",
+                        description: "Check framework compliance and generate enforcement actions",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                content: { type: "string" },
+                                operation: { type: "string" },
+                                context: { type: "object" },
+                            },
+                            required: ["content", "operation"],
+                        },
+                    },
+                ],
+            };
+        });
+        // Handle tool calls
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            switch (name) {
+                case "execute-pre-processors":
+                    return await this.handlePreProcessors(args);
+                case "execute-post-processors":
+                    return await this.handlePostProcessors(args);
+                case "codex-validation":
+                    return await this.handleCodexValidation(args);
+                case "framework-compliance-check":
+                    return await this.handleComplianceCheck(args);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        });
+    }
+    async handlePreProcessors(args) {
+        const content = args.content;
+        const context = args.context || {};
+        const validateCodex = args.validateCodex !== false;
+        const strictMode = args.strictMode || false;
+        // Silent execution - no console output
+        const results = {
+            processed: content,
+            validations: [],
+            warnings: [],
+            blocked: false,
+            reason: "",
+        };
+        try {
+            // 1. Input sanitization
+            results.processed = this.sanitizeInput(content);
+            // 2. Codex validation (if enabled)
+            if (validateCodex) {
+                const codexResults = await this.validateAgainstCodex(results.processed, strictMode);
+                results.validations.push(...codexResults.validations);
+                results.warnings.push(...codexResults.warnings);
+                if (codexResults.blocked) {
+                    results.blocked = true;
+                    results.reason = codexResults.reason;
+                }
+            }
+            // 3. Context enrichment
+            results.processed = this.enrichWithContext(results.processed, context);
+            // 4. Security checks
+            const securityResults = this.performSecurityChecks(results.processed);
+            results.warnings.push(...securityResults.warnings);
+        }
+        catch (error) {
+            results.blocked = true;
+            results.reason = `Pre-processing error: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        const response = `🔄 Pre-Processor Results
+
+**Content Length:** ${results.processed.length} characters
+**Validations Passed:** ${results.validations.length}
+**Warnings:** ${results.warnings.length}
+${results.warnings.length > 0 ? results.warnings.map((w) => `• ⚠️ ${w}`).join("\n") : ""}
+
+**Status:** ${results.blocked ? `❌ BLOCKED - ${results.reason}` : "✅ APPROVED FOR EXECUTION"}`;
+        return {
+            content: [{ type: "text", text: response }],
+        };
+    }
+    async handlePostProcessors(args) {
+        const content = args.content;
+        const results = args.results || {};
+        const enforceCompliance = args.enforceCompliance !== false;
+        const auditTrail = args.auditTrail !== false;
+        // Silent execution - no console output
+        const postResults = {
+            processed: content,
+            compliance: [],
+            auditEntries: [],
+            recommendations: [],
+            finalApproval: true,
+        };
+        try {
+            // 1. Result validation
+            postResults.processed = this.validateResults(content, results);
+            // 2. Compliance enforcement
+            if (enforceCompliance) {
+                const complianceResults = await this.enforceCompliance(postResults.processed);
+                postResults.compliance.push(...complianceResults.compliance);
+                postResults.recommendations.push(...complianceResults.recommendations);
+                if (!complianceResults.approved) {
+                    postResults.finalApproval = false;
+                }
+            }
+            // 3. Audit trail generation
+            if (auditTrail) {
+                postResults.auditEntries = this.generateAuditTrail(content, results, postResults);
+            }
+            // 4. Quality assurance
+            const qaResults = this.performQualityAssurance(postResults.processed);
+            postResults.recommendations.push(...qaResults.recommendations);
+        }
+        catch (error) {
+            postResults.finalApproval = false;
+            postResults.recommendations.push(`Post-processing error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const response = `🔄 Post-Processor Results
+
+**Final Approval:** ${postResults.finalApproval ? "✅ APPROVED" : "❌ REQUIRES REVIEW"}
+**Compliance Checks:** ${postResults.compliance.length}
+**Audit Entries:** ${postResults.auditEntries.length}
+**Recommendations:** ${postResults.recommendations.length}
+
+**Recommendations:**
+${postResults.recommendations.length > 0 ? postResults.recommendations.map((r) => `• 💡 ${r}`).join("\n") : "None"}
+
+**Audit Summary:**
+${postResults.auditEntries
+            .slice(0, 3)
+            .map((a) => `• 📝 ${a}`)
+            .join("\n")}${postResults.auditEntries.length > 3 ? "\n• ..." : ""}`;
+        return {
+            content: [{ type: "text", text: response }],
+        };
+    }
+    async handleCodexValidation(args) {
+        const content = args.content;
+        const terms = args.terms || ["all"];
+        const strict = args.strict || false;
+        // Silent validation - no console output
+        try {
+            const validationResults = await this.validateAgainstCodex(content, strict, terms);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `📚 Codex Validation Results
+
+**Content Validated:** ${content.length} characters
+**Terms Checked:** ${terms.length === 1 && terms[0] === "all" ? "All 55-terms" : terms.length}
+**Compliance:** ${validationResults.compliance}%
+
+**Violations:** ${validationResults.violations.length}
+${validationResults.violations.map((v) => `• ❌ ${v}`).join("\n") || "None"}
+
+**Warnings:** ${validationResults.warnings.length}
+${validationResults.warnings.map((w) => `• ⚠️ ${w}`).join("\n") || "None"}
+
+**Recommendations:**
+${validationResults.recommendations.map((r) => `• 💡 ${r}`).join("\n") || "None"}
+
+**Status:** ${validationResults.blocked ? "❌ BLOCKED" : "✅ COMPLIANT"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Codex validation failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    async handleComplianceCheck(args) {
+        const content = args.content;
+        const operation = args.operation;
+        const context = args.context || {};
+        // Silent compliance check - no console output
+        try {
+            const complianceResults = await this.checkFrameworkCompliance(content, operation, context);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `📋 Framework Compliance Check
+
+**Operation:** ${operation}
+**Content Type:** ${this.detectContentType(content)}
+
+**Compliance Score:** ${complianceResults.score}/100
+**Critical Issues:** ${complianceResults.criticalIssues.length}
+**Warnings:** ${complianceResults.warnings.length}
+
+**Critical Issues:**
+${complianceResults.criticalIssues.map((i) => `• ❌ ${i}`).join("\n") || "None"}
+
+**Warnings:**
+${complianceResults.warnings.map((w) => `• ⚠️ ${w}`).join("\n") || "None"}
+
+**Enforcement Actions:**
+${complianceResults.actions.map((a) => `• 🔧 ${a}`).join("\n") || "None required"}
+
+**Status:** ${complianceResults.approved ? "✅ COMPLIANT" : "❌ REQUIRES CORRECTION"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Compliance check failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    sanitizeInput(content) {
+        // Basic input sanitization
+        return content
+            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "[SCRIPT REMOVED]")
+            .replace(/javascript:/gi, "[JAVASCRIPT REMOVED]")
+            .trim();
+    }
+    async validateAgainstCodex(content, strict, terms) {
+        const results = {
+            validations: [],
+            warnings: [],
+            violations: [],
+            recommendations: [],
+            compliance: 0,
+            blocked: false,
+            reason: "",
+        };
+        // Use loaded codex rules if available, otherwise fall back to hardcoded terms
+        if (this.codexRules.length > 0) {
+            const termsToCheck = terms && terms.length > 0 && !terms.includes("all")
+                ? terms
+                : this.codexRules.map(r => r.name);
+            let passed = 0;
+            for (const rule of this.codexRules) {
+                // Filter by requested terms if specified
+                if (terms && terms.length > 0 && !terms.includes("all") && !terms.includes(rule.name)) {
+                    continue;
+                }
+                try {
+                    const context = {
+                        newCode: content,
+                        operation: "write",
+                        files: []
+                    };
+                    const validationResult = await rule.validator(context);
+                    if (validationResult.passed) {
+                        passed++;
+                        results.validations.push(`${rule.name}: PASS`);
+                    }
+                    else {
+                        results.violations.push(`${rule.name}: ${validationResult.message}`);
+                        results.recommendations.push(...(validationResult.suggestions || []));
+                        const isBlocking = rule.severity === "blocking" || rule.severity === "error";
+                        if (strict || isBlocking) {
+                            results.blocked = true;
+                            results.reason = `Codex violation: ${rule.name}`;
+                        }
+                    }
+                }
+                catch (err) {
+                    results.warnings.push(`${rule.name}: Validation error - ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            results.compliance = termsToCheck.length > 0
+                ? Math.round((passed / termsToCheck.length) * 100)
+                : 100;
+            return results;
+        }
+        // Fallback to hardcoded term checking (legacy behavior)
+        const termsToCheck = terms && terms.length > 0 && !terms.includes("all")
+            ? terms
+            : this.codexTerms;
+        let passed = 0;
+        for (const term of termsToCheck) {
+            const termResult = this.checkCodexTerm(content, term);
+            if (termResult.passed) {
+                passed++;
+                results.validations.push(`${term}: PASS`);
+            }
+            else {
+                results.violations.push(`${term}: ${termResult.reason}`);
+                results.recommendations.push(termResult.recommendation);
+                if (strict || termResult.critical) {
+                    results.blocked = true;
+                    results.reason = `Codex violation: ${term}`;
+                }
+            }
+        }
+        results.compliance = Math.round((passed / termsToCheck.length) * 100);
+        return results;
+    }
+    checkCodexTerm(content, term) {
+        // Simplified codex term checking
+        switch (term) {
+            case "Type Safety First":
+                return {
+                    passed: !content.includes("any") || content.includes("// @ts-ignore"),
+                    reason: "Type safety violations detected",
+                    recommendation: "Use proper TypeScript types instead of any",
+                    critical: false,
+                };
+            case "No Stubs/Patches":
+                return {
+                    passed: !content.includes("TODO") && !content.includes("FIXME"),
+                    reason: "Stub code or patches detected",
+                    recommendation: "Implement complete functionality or remove placeholder code",
+                    critical: true,
+                };
+            case "Progressive Prod-Ready Code":
+                return {
+                    passed: !content.includes("console.log") || content.includes("production"),
+                    reason: "Non-production ready code detected",
+                    recommendation: "Remove debug statements and ensure production readiness",
+                    critical: false,
+                };
+            default:
+                return {
+                    passed: true,
+                    reason: "",
+                    recommendation: "",
+                    critical: false,
+                };
+        }
+    }
+    enrichWithContext(content, context) {
+        if (context.codex != null) {
+            return `/* 0xRay Framework - Codex Compliant */\n${content}`;
+        }
+        return content;
+    }
+    performSecurityChecks(content) {
+        const warnings = [];
+        if (content.includes("eval(")) {
+            warnings.push("Use of eval() detected - security risk");
+        }
+        if (content.includes("innerHTML")) {
+            warnings.push("Direct innerHTML manipulation detected - XSS risk");
+        }
+        return { warnings };
+    }
+    validateResults(content, results) {
+        if (results.error != null) {
+            return `${content}\n/* ERROR: ${String(results.error)} */`;
+        }
+        return content;
+    }
+    async enforceCompliance(content) {
+        const results = {
+            compliance: [],
+            recommendations: [],
+            approved: true,
+        };
+        // Check bundle size compliance (if applicable)
+        if (content.includes("import") && content.length > 50000) {
+            results.compliance.push("Large module detected - consider code splitting");
+            results.recommendations.push("Implement lazy loading or split large modules");
+        }
+        // Check for performance issues
+        if (content.includes("for") &&
+            content.includes("length") &&
+            content.includes("i++")) {
+            results.recommendations.push("Consider using for...of loops or array methods for better performance");
+        }
+        return results;
+    }
+    generateAuditTrail(content, results, postResults) {
+        const audit = [
+            `Operation completed at ${new Date().toISOString()}`,
+            `Content length: ${content.length}`,
+            `Processing time: ${String(results.duration ?? "unknown")}ms`,
+            `Compliance status: ${postResults.finalApproval ? "approved" : "requires review"}`,
+        ];
+        return audit;
+    }
+    performQualityAssurance(content) {
+        const recommendations = [];
+        // Basic quality checks
+        if (content.split("\n").length > 100) {
+            recommendations.push("Consider breaking down large files into smaller modules");
+        }
+        if (content.includes("function") && content.split("function").length > 10) {
+            recommendations.push("High function count - consider consolidating related functions");
+        }
+        return { recommendations };
+    }
+    detectContentType(content) {
+        if (content.includes("function") ||
+            content.includes("const") ||
+            content.includes("let")) {
+            return "JavaScript/TypeScript";
+        }
+        if (content.includes("class") || content.includes("def ")) {
+            return "Python";
+        }
+        if (content.includes("<") && content.includes(">")) {
+            return "HTML/XML";
+        }
+        return "Text";
+    }
+    async checkFrameworkCompliance(content, operation, context) {
+        const results = {
+            score: 100,
+            criticalIssues: [],
+            warnings: [],
+            actions: [],
+            approved: true,
+        };
+        // Operation-specific compliance checks
+        switch (operation) {
+            case "code-review":
+                if (!content.includes("function") && !content.includes("class")) {
+                    results.warnings.push("No functions or classes detected in code review");
+                }
+                break;
+            case "security-audit":
+                if (!content.includes("auth") && !content.includes("security")) {
+                    results.warnings.push("Limited security-related content detected");
+                }
+                break;
+            case "testing":
+                if (!content.includes("test") && !content.includes("spec")) {
+                    results.warnings.push("No test-related content detected");
+                }
+                break;
+        }
+        // General compliance checks
+        if (content.length > 10000) {
+            results.score -= 10;
+            results.warnings.push("Large content size - consider splitting");
+        }
+        if (results.criticalIssues.length > 0) {
+            results.approved = false;
+            results.score -= 30;
+        }
+        return results;
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        // Silent start - no console output
+    }
+}
+// Start the server if run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const server = new StringRayProcessorPipelineServer();
+    server.run().catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
+}
+export { StringRayProcessorPipelineServer };

package/dist/mcps/protocol/protocol-constants.js

@@ -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 const MCP_PROTOCOL_VERSION = '2024-11-05';
+/**
+ * JSON-RPC Protocol Version
+ * Standard JSON-RPC version used by MCP
+ */
+export const JSONRPC_VERSION = '2.0';
+/**
+ * MCP Method Names
+ * Standard MCP protocol method identifiers
+ */
+export const MCP_METHODS = {
+    INITIALIZE: 'initialize',
+    TOOLS_LIST: 'tools/list',
+    TOOLS_CALL: 'tools/call',
+};
+/**
+ * Default Timeout Values
+ * Millisecond timeouts for various MCP operations
+ */
+export const DEFAULT_TIMEOUTS = {
+    CONNECTION: 30000,
+    REQUEST: 60000,
+    INITIALIZATION: 10000,
+};
+/**
+ * Error Codes
+ * Standard JSON-RPC error codes used by MCP
+ */
+export const ERROR_CODES = {
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+    SERVER_ERROR: -32000,
+};