xypriss 1.0.1 → 1.1.2

package/dist/esm/cluster/modules/IPCManager.js

@@ -1,759 +0,0 @@
-import { EventEmitter } from 'events';
-import * as crypto from 'crypto';
-import * as msgpack from 'msgpack-lite';
-import stringify from 'fast-json-stable-stringify';
-import { createSecurityError, ErrorSeverity, ErrorType } from '../../mods/toolkit/src/utils/errorHandler.js';
-import { func } from '../../mods/toolkit/src/components/fortified-function/index.js';
-import { logger } from '../../server/utils/Logger.js';
-
-/**
- * XyPrissJS IPC Manager
- * Secure inter-process communication with encryption and message queuing
- */
-/**
- * Secure IPC manager with encryption, message queuing, and broadcast capabilities
- */
-class IPCManager extends EventEmitter {
-    constructor(config, errorLogger) {
-        super();
-        this.messageQueues = new Map();
-        this.messageHandlers = new Map();
-        this.pendingMessages = new Map();
-        this.config = config;
-        this.errorLogger = errorLogger;
-        this.isEnabled = config.ipc?.enabled !== false;
-        // Generate encryption key for secure IPC
-        this.encryptionKey = this.generateEncryptionKey();
-        if (this.isEnabled) {
-            this.setupIPC();
-        }
-    }
-    /**
-     * Setup IPC with security and message handling
-     */
-    setupIPC() {
-        // Setup message handlers from config
-        if (this.config.ipc?.events) {
-            Object.entries(this.config.ipc.events).forEach(([eventName, handler]) => {
-                this.messageHandlers.set(eventName, handler);
-            });
-        }
-        // Setup cluster message handling
-        this.setupClusterMessageHandling();
-        // Initialize message queues for workers
-        this.initializeMessageQueues();
-        logger.info("cluster", "IPC Manager initialized with secure communication");
-    }
-    /**
-     * Setup cluster message handling with fortified security
-     */
-    setupClusterMessageHandling() {
-        const fortifiedHandler = func(async (worker, message) => {
-            await this.handleIncomingMessage(worker, message);
-        }, {
-            ultraFast: "maximum",
-            auditLog: true,
-            errorHandling: "graceful",
-        });
-        // Handle messages from workers (master process)
-        if (process.env.NODE_ENV !== "worker") {
-            // Setup proper cluster event handling for master process
-            const clusterModule = require("cluster");
-            // Listen for messages from all workers
-            clusterModule.on("message", (worker, message) => {
-                fortifiedHandler(worker, message);
-            });
-            // Setup worker lifecycle event handlers
-            clusterModule.on("fork", (worker) => {
-                worker.on("message", (message) => {
-                    fortifiedHandler(worker, message);
-                });
-            });
-        }
-        // Handle messages from master (worker process)
-        if (process.env.NODE_ENV === "worker") {
-            process.on("message", (message) => {
-                // Create worker object with proper identification
-                const workerObj = {
-                    id: process.env.WORKER_ID ||
-                        process.pid?.toString() ||
-                        "unknown",
-                    process: { pid: process.pid },
-                    isDead: () => false,
-                };
-                fortifiedHandler(workerObj, message);
-            });
-        }
-    }
-    /**
-     * Initialize message queues for workers
-     */
-    initializeMessageQueues() {
-        const queueConfig = this.config.ipc?.messageQueue || {};
-        const maxSize = queueConfig.maxSize || 1000;
-        const timeout = queueConfig.timeout || 30000;
-        // Create default queue
-        this.messageQueues.set("default", {
-            messages: [],
-            maxSize,
-            timeout,
-        });
-    }
-    /**
-     * Handle incoming IPC messages with security validation
-     */
-    async handleIncomingMessage(worker, message) {
-        try {
-            // Skip Node.js internal cluster messages
-            if (this.isNodeInternalMessage(message)) {
-                return; // Silently ignore internal messages
-            }
-            // Deserialize message first
-            const deserializedMessage = this.deserializeMessage(message);
-            // Validate message structure
-            if (!this.isValidIPCMessage(deserializedMessage)) {
-                // Only log if it looks like it might be our message format
-                if (this.looksLikeXyPrissMessage(deserializedMessage)) {
-                    // Debug logging to understand what messages are failing
-                    if (process.env.DEBUG_IPC) {
-                        logger.info("cluster", "Invalid XyPrissJS message:", {
-                            original: message,
-                            deserialized: deserializedMessage,
-                            hasId: !!deserializedMessage?.id,
-                            hasType: !!deserializedMessage?.type,
-                            hasFrom: !!deserializedMessage?.from,
-                            hasTo: !!deserializedMessage?.to,
-                            hasTimestamp: !!deserializedMessage?.timestamp,
-                        });
-                    }
-                    throw new Error("Invalid IPC message structure");
-                }
-                return; // Silently ignore non-XyPrissJS messages
-            }
-            const ipcMessage = deserializedMessage;
-            // Decrypt message if encrypted
-            if (ipcMessage.encrypted && this.config.security?.encryptIPC) {
-                ipcMessage.data = this.decryptMessage(ipcMessage.data);
-            }
-            // Verify message signature if security is enabled
-            if (this.config.security?.encryptIPC && ipcMessage.signature) {
-                if (!this.verifyMessageSignature(ipcMessage)) {
-                    throw new Error("Message signature verification failed");
-                }
-            }
-            // Handle different message types
-            await this.processMessage(ipcMessage, worker);
-        }
-        catch (error) {
-            // Only log errors for messages that look like they should be ours
-            const deserializedMessage = this.deserializeMessage(message);
-            if (this.looksLikeXyPrissMessage(deserializedMessage)) {
-                const securityError = createSecurityError(`IPC message handling failed: ${error.message}`, ErrorType.INTERNAL, ErrorSeverity.MEDIUM, "IPC_MESSAGE_ERROR", { operation: "ipc_message_handling" });
-                this.errorLogger.logError(securityError);
-            }
-        }
-    }
-    /**
-     * Process IPC message based on type
-     */
-    async processMessage(message, worker) {
-        switch (message.type) {
-            case "request":
-                await this.handleRequest(message, worker);
-                break;
-            case "response":
-                await this.handleResponse(message);
-                break;
-            case "broadcast":
-                await this.handleBroadcast(message);
-                break;
-            case "event":
-                await this.handleEvent(message);
-                break;
-            default:
-                console.warn(`Unknown IPC message type: ${message.type}`);
-        }
-        // Emit IPC event
-        this.emit("ipc:message", message.from, message.to, message.data);
-    }
-    /**
-     * Handle request messages
-     */
-    async handleRequest(message, _worker) {
-        const handler = this.messageHandlers.get(message.data.event);
-        if (handler) {
-            try {
-                const result = handler(message.data.payload, message.from);
-                // Send response back
-                await this.sendResponse(message.from, message.id, result);
-            }
-            catch (error) {
-                await this.sendResponse(message.from, message.id, {
-                    error: error.message,
-                });
-            }
-        }
-        else {
-            await this.sendResponse(message.from, message.id, {
-                error: "No handler found",
-            });
-        }
-    }
-    /**
-     * Handle response messages
-     */
-    async handleResponse(message) {
-        const pending = this.pendingMessages.get(message.id);
-        if (pending) {
-            clearTimeout(pending.timeout);
-            this.pendingMessages.delete(message.id);
-            if (message.data.error) {
-                pending.reject(new Error(message.data.error));
-            }
-            else {
-                pending.resolve(message.data.result);
-            }
-        }
-    }
-    /**
-     * Handle broadcast messages
-     */
-    async handleBroadcast(message) {
-        const handler = this.messageHandlers.get(message.data.event);
-        if (handler) {
-            try {
-                handler(message.data.payload, message.from);
-            }
-            catch (error) {
-                console.error(`Broadcast handler error: ${error.message}`);
-            }
-        }
-        this.emit("ipc:broadcast", message.from, message.data);
-    }
-    /**
-     * Handle event messages
-     */
-    async handleEvent(message) {
-        this.emit(message.data.event, message.data.payload, message.from);
-    }
-    /**
-     * Send message to specific worker
-     */
-    async sendToWorker(workerId, data) {
-        if (!this.isEnabled)
-            return;
-        const message = this.createMessage("event", workerId, data);
-        await this.deliverMessage(message);
-    }
-    /**
-     * Send message to all workers
-     */
-    async sendToAllWorkers(data) {
-        if (!this.isEnabled)
-            return;
-        const message = this.createMessage("broadcast", "broadcast", data);
-        await this.deliverMessage(message);
-    }
-    /**
-     * Broadcast message to all workers
-     */
-    async broadcast(data) {
-        await this.sendToAllWorkers(data);
-    }
-    /**
-     * Send message to random worker
-     */
-    async sendToRandomWorker(data) {
-        if (!this.isEnabled)
-            return;
-        const workers = this.getAvailableWorkers();
-        if (workers.length === 0) {
-            throw new Error("No available workers for message delivery");
-        }
-        const randomWorker = workers[Math.floor(Math.random() * workers.length)];
-        await this.sendToWorker(randomWorker, data);
-    }
-    /**
-     * Send message to least loaded worker
-     */
-    async sendToLeastLoadedWorker(data) {
-        if (!this.isEnabled)
-            return;
-        const workers = this.getAvailableWorkers();
-        if (workers.length === 0) {
-            throw new Error("No available workers for message delivery");
-        }
-        // Find least loaded worker based on current metrics
-        let leastLoadedWorker = workers[0];
-        let lowestLoad = this.getWorkerLoad(leastLoadedWorker);
-        for (const workerId of workers) {
-            const load = this.getWorkerLoad(workerId);
-            if (load < lowestLoad) {
-                lowestLoad = load;
-                leastLoadedWorker = workerId;
-            }
-        }
-        await this.sendToWorker(leastLoadedWorker, data);
-    }
-    /**
-     * Send request and wait for response
-     */
-    async sendRequest(workerId, event, payload, timeout = 5000) {
-        if (!this.isEnabled) {
-            throw new Error("IPC is disabled");
-        }
-        const message = this.createMessage("request", workerId, {
-            event,
-            payload,
-        });
-        return new Promise((resolve, reject) => {
-            const timeoutHandle = setTimeout(() => {
-                this.pendingMessages.delete(message.id);
-                reject(new Error("Request timeout"));
-            }, timeout);
-            this.pendingMessages.set(message.id, {
-                resolve,
-                reject,
-                timeout: timeoutHandle,
-            });
-            this.deliverMessage(message).catch(reject);
-        });
-    }
-    /**
-     * Send response to request
-     */
-    async sendResponse(workerId, requestId, result) {
-        const message = this.createMessage("response", workerId, { result });
-        message.id = requestId; // Use same ID as request
-        await this.deliverMessage(message);
-    }
-    /**
-     * Create IPC message with security features
-     */
-    createMessage(type, to, data) {
-        const message = {
-            id: this.generateMessageId(),
-            type,
-            from: process.env.NODE_ENV !== "worker"
-                ? "master"
-                : `worker_${process.env.WORKER_ID || "unknown"}`,
-            to,
-            data,
-            timestamp: Date.now(),
-        };
-        // Encrypt message if security is enabled
-        if (this.config.security?.encryptIPC) {
-            message.data = this.encryptMessage(message.data);
-            message.encrypted = true;
-            message.signature = this.signMessage(message);
-        }
-        return message;
-    }
-    /**
-     * Deliver message to target using real cluster IPC
-     */
-    async deliverMessage(message) {
-        try {
-            // Serialize message using msgpack for better performance
-            const serializedMessage = this.serializeMessage(message);
-            if (message.to === "broadcast") {
-                // Broadcast to all workers using real cluster API
-                await this.broadcastToAllWorkers(serializedMessage);
-            }
-            else if (process.env.NODE_ENV !== "worker") {
-                // Send from master to specific worker
-                await this.sendToSpecificWorker(message.to, serializedMessage);
-            }
-            else {
-                // Send from worker to master
-                if (process.send) {
-                    process.send(serializedMessage);
-                }
-                else {
-                    throw new Error("Process.send not available in worker");
-                }
-            }
-        }
-        catch (error) {
-            const securityError = createSecurityError(`Message delivery failed: ${error.message}`, ErrorType.INTERNAL, ErrorSeverity.MEDIUM, "IPC_DELIVERY_ERROR", { operation: "ipc_message_delivery" });
-            this.errorLogger.logError(securityError);
-            throw error;
-        }
-    }
-    /**
-     * Broadcast message to all workers using real cluster API
-     */
-    async broadcastToAllWorkers(serializedMessage) {
-        try {
-            const clusterModule = require("cluster");
-            if (clusterModule.workers) {
-                const broadcastPromises = Object.values(clusterModule.workers).map((worker) => {
-                    return new Promise((resolve) => {
-                        if (worker && !worker.isDead() && worker.send) {
-                            worker.send(serializedMessage, (error) => {
-                                if (error) {
-                                    console.warn(`Failed to send message to worker ${worker.id}:`, error.message);
-                                }
-                                resolve(); // Continue even if one worker fails
-                            });
-                        }
-                        else {
-                            resolve();
-                        }
-                    });
-                });
-                await Promise.all(broadcastPromises);
-            }
-        }
-        catch (error) {
-            throw new Error(`Broadcast failed: ${error.message}`);
-        }
-    }
-    /**
-     * Send message to specific worker using real cluster API
-     */
-    async sendToSpecificWorker(workerId, serializedMessage) {
-        try {
-            const clusterModule = require("cluster");
-            const id = workerId.replace("worker_", "").split("_")[0];
-            const worker = clusterModule.workers?.[id];
-            if (worker && !worker.isDead() && worker.send) {
-                return new Promise((resolve, reject) => {
-                    worker.send(serializedMessage, (error) => {
-                        if (error) {
-                            reject(new Error(`Failed to send message to worker ${workerId}: ${error.message}`));
-                        }
-                        else {
-                            resolve();
-                        }
-                    });
-                });
-            }
-            else {
-                throw new Error(`Worker ${workerId} not found or not available`);
-            }
-        }
-        catch (error) {
-            throw new Error(`Send to worker failed: ${error.message}`);
-        }
-    }
-    /**
-     * Serialize message using msgpack for better performance
-     */
-    serializeMessage(message) {
-        try {
-            // Use msgpack for binary serialization (more efficient than JSON)
-            if (this.config.ipc?.serialization === "msgpack") {
-                return {
-                    ...message,
-                    data: msgpack.encode(message.data),
-                    _serialized: "msgpack",
-                };
-            }
-            else {
-                // Use stable JSON stringify for consistent serialization
-                return {
-                    ...message,
-                    data: stringify(message.data),
-                    _serialized: "json",
-                };
-            }
-        }
-        catch (error) {
-            // Fallback to regular JSON
-            return {
-                ...message,
-                data: JSON.stringify(message.data),
-                _serialized: "json",
-            };
-        }
-    }
-    /**
-     * Deserialize message data
-     */
-    deserializeMessage(message) {
-        try {
-            if (message._serialized === "msgpack") {
-                return {
-                    ...message,
-                    data: msgpack.decode(message.data),
-                };
-            }
-            else {
-                return {
-                    ...message,
-                    data: JSON.parse(message.data),
-                };
-            }
-        }
-        catch (error) {
-            // Return as-is if deserialization fails
-            return message;
-        }
-    }
-    /**
-     * Check if message is a Node.js internal cluster message
-     */
-    isNodeInternalMessage(message) {
-        // Node.js cluster internal messages typically have these patterns
-        if (!message || typeof message !== "object") {
-            return true; // Ignore non-object messages
-        }
-        // Check for Node.js specific properties first
-        if (message.cmd ||
-            message.act ||
-            message.NODE_UNIQUE_ID ||
-            message.NODE_CHANNEL_FD) {
-            return true;
-        }
-        // Check for common Node.js cluster message types
-        if (message.cmd === "NODE_CLUSTER" ||
-            message.cmd === "NODE_HANDLE" ||
-            message.cmd === "NODE_HANDLE_ACK" ||
-            message.cmd === "NODE_HANDLE_NACK") {
-            return true;
-        }
-        // Check for server/worker lifecycle messages
-        if (typeof message === "object" &&
-            (message.listening !== undefined ||
-                message.disconnect !== undefined ||
-                message.suicide !== undefined ||
-                message.exitedAfterDisconnect !== undefined)) {
-            return true;
-        }
-        // Common Node.js cluster internal message patterns
-        const internalPatterns = [
-            '"cmd":', // Node.js cluster command messages
-            '"act":', // Node.js cluster action messages
-            "NODE_", // Node.js internal prefixes
-            '"listening":', // Server listening events
-            '"disconnect":', // Disconnect events
-            '"suicide":', // Worker suicide flag
-            '"exitedAfterDisconnect":', // Worker exit flag
-        ];
-        // Check if message has internal patterns
-        const messageStr = JSON.stringify(message);
-        for (const pattern of internalPatterns) {
-            if (messageStr.includes(pattern)) {
-                return true;
-            }
-        }
-        // Check for messages that don't have our required structure
-        // but might be valid Node.js messages
-        if (!message.id &&
-            !message.type &&
-            !message.from &&
-            !message.to &&
-            !message._serialized) {
-            return true; // Likely a Node.js internal message
-        }
-        return false;
-    }
-    /**
-     * Check if message looks like a XyPrissJS message
-     */
-    looksLikeXyPrissMessage(message) {
-        if (!message || typeof message !== "object") {
-            return false;
-        }
-        // Check for XyPrissJS cluster lifecycle messages (these are valid but incomplete)
-        const clusterLifecycleTypes = [
-            "worker_ready",
-            "worker_started",
-            "worker_stopped",
-            "worker_error",
-            "cluster_ready",
-            "health_check",
-            "metrics_update",
-        ];
-        if (message.type && clusterLifecycleTypes.includes(message.type)) {
-            return false; // These are valid XyPrissJS messages but don't need full IPC structure
-        }
-        // Check if it has some XyPrissJS IPC message characteristics
-        return (message.id ||
-            message.from ||
-            message.to ||
-            message.timestamp ||
-            message._serialized ||
-            message.encrypted);
-    }
-    /**
-     * Validate IPC message structure
-     */
-    isValidIPCMessage(message) {
-        return (message &&
-            typeof message.id === "string" &&
-            typeof message.type === "string" &&
-            typeof message.from === "string" &&
-            typeof message.to === "string" &&
-            typeof message.timestamp === "number");
-    }
-    /**
-     * Generate unique message ID
-     */
-    generateMessageId() {
-        return `msg_${Date.now()}_${Math.random()
-            .toString(36)
-            .substring(2, 11)}`;
-    }
-    /**
-     * Generate encryption key
-     */
-    generateEncryptionKey() {
-        return crypto.randomBytes(32).toString("hex");
-    }
-    /**
-     * Encrypt message data using modern crypto API
-     */
-    encryptMessage(data) {
-        try {
-            const algorithm = "aes-256-gcm";
-            const key = crypto.scryptSync(this.encryptionKey, "salt", 32);
-            const iv = crypto.randomBytes(16);
-            const cipher = crypto.createCipheriv(algorithm, key, iv);
-            cipher.setAAD(Buffer.from("ipc-message", "utf8"));
-            let encrypted = cipher.update(JSON.stringify(data), "utf8", "hex");
-            encrypted += cipher.final("hex");
-            const authTag = cipher.getAuthTag();
-            return JSON.stringify({
-                encrypted,
-                iv: iv.toString("hex"),
-                authTag: authTag.toString("hex"),
-            });
-        }
-        catch (error) {
-            // Fallback to simple base64 encoding if encryption fails
-            return Buffer.from(JSON.stringify(data)).toString("base64");
-        }
-    }
-    /**
-     * Decrypt message data using modern crypto API
-     */
-    decryptMessage(encryptedData) {
-        try {
-            const encryptedObj = JSON.parse(encryptedData);
-            if (encryptedObj.encrypted &&
-                encryptedObj.iv &&
-                encryptedObj.authTag) {
-                const algorithm = "aes-256-gcm";
-                const key = crypto.scryptSync(this.encryptionKey, "salt", 32);
-                const iv = Buffer.from(encryptedObj.iv, "hex");
-                const decipher = crypto.createDecipheriv(algorithm, key, iv);
-                decipher.setAuthTag(Buffer.from(encryptedObj.authTag, "hex"));
-                decipher.setAAD(Buffer.from("ipc-message", "utf8"));
-                let decrypted = decipher.update(encryptedObj.encrypted, "hex", "utf8");
-                decrypted += decipher.final("utf8");
-                return JSON.parse(decrypted);
-            }
-            else {
-                // Fallback: assume it's base64 encoded
-                const decoded = Buffer.from(encryptedData, "base64").toString("utf8");
-                return JSON.parse(decoded);
-            }
-        }
-        catch (error) {
-            // If all else fails, try to parse as plain JSON
-            try {
-                return JSON.parse(encryptedData);
-            }
-            catch {
-                return encryptedData;
-            }
-        }
-    }
-    /**
-     * Sign message for integrity verification
-     */
-    signMessage(message) {
-        const messageString = JSON.stringify({
-            id: message.id,
-            type: message.type,
-            from: message.from,
-            to: message.to,
-            timestamp: message.timestamp,
-        });
-        return crypto
-            .createHmac("sha256", this.encryptionKey)
-            .update(messageString)
-            .digest("hex");
-    }
-    /**
-     * Verify message signature
-     */
-    verifyMessageSignature(message) {
-        if (!message.signature)
-            return false;
-        const expectedSignature = this.signMessage(message);
-        return crypto.timingSafeEqual(Buffer.from(message.signature, "hex"), Buffer.from(expectedSignature, "hex"));
-    }
-    /**
-     * Register event handler
-     */
-    registerHandler(event, handler) {
-        this.messageHandlers.set(event, handler);
-    }
-    /**
-     * Unregister event handler
-     */
-    unregisterHandler(event) {
-        this.messageHandlers.delete(event);
-    }
-    /**
-     * Set worker manager reference for integration
-     */
-    setWorkerManager(workerManager) {
-        this.workerManager = workerManager;
-    }
-    /**
-     * Get available workers from cluster
-     */
-    getAvailableWorkers() {
-        try {
-            const clusterModule = require("cluster");
-            if (clusterModule.workers) {
-                return Object.values(clusterModule.workers)
-                    .filter((worker) => worker && !worker.isDead())
-                    .map((worker) => `worker_${worker.id}`);
-            }
-            return [];
-        }
-        catch (error) {
-            return [];
-        }
-    }
-    /**
-     * Get worker load score for load balancing
-     */
-    getWorkerLoad(workerId) {
-        try {
-            // If worker manager is available, get real metrics
-            if (this.workerManager) {
-                const worker = this.workerManager.getWorker(workerId);
-                if (worker) {
-                    // Calculate load based on CPU and memory usage
-                    return (worker.cpu.usage + worker.memory.percentage) / 2;
-                }
-            }
-            // Fallback: use random load to distribute evenly
-            return Math.random() * 100;
-        }
-        catch (error) {
-            return 50; // Default moderate load
-        }
-    }
-    /**
-     * Get IPC statistics
-     */
-    getStats() {
-        return {
-            enabled: this.isEnabled,
-            messageQueues: this.messageQueues.size,
-            pendingMessages: this.pendingMessages.size,
-            handlers: this.messageHandlers.size,
-            availableWorkers: this.getAvailableWorkers().length,
-        };
-    }
-}
-
-export { IPCManager };
-//# sourceMappingURL=IPCManager.js.map