@serve.zone/dcrouter 8.1.0 → 9.1.0

package/dist_ts/opsserver/handlers/stats.handler.js

@@ -0,0 +1,400 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+import { MetricsManager } from '../../monitoring/index.js';
+import { SecurityLogger } from '../../security/classes.securitylogger.js';
+export class StatsHandler {
+    opsServerRef;
+    typedrouter = new plugins.typedrequest.TypedRouter();
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        // Add this handler's router to the parent
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        // Server Statistics Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getServerStatistics', async (dataArg, toolsArg) => {
+            const stats = await this.collectServerStats();
+            return {
+                stats: {
+                    uptime: stats.uptime,
+                    startTime: Date.now() - (stats.uptime * 1000),
+                    memoryUsage: stats.memoryUsage,
+                    cpuUsage: stats.cpuUsage,
+                    activeConnections: stats.activeConnections,
+                    totalConnections: stats.totalConnections,
+                    requestsPerSecond: stats.requestsPerSecond,
+                    throughput: stats.throughput,
+                },
+                history: dataArg.includeHistory ? stats.history : undefined,
+            };
+        }));
+        // Email Statistics Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getEmailStatistics', async (dataArg, toolsArg) => {
+            const emailServer = this.opsServerRef.dcRouterRef.emailServer;
+            if (!emailServer) {
+                return {
+                    stats: {
+                        sent: 0,
+                        received: 0,
+                        bounced: 0,
+                        queued: 0,
+                        failed: 0,
+                        averageDeliveryTime: 0,
+                        deliveryRate: 0,
+                        bounceRate: 0,
+                    },
+                };
+            }
+            const stats = await this.collectEmailStats();
+            return {
+                stats: {
+                    sent: stats.sentToday,
+                    received: stats.receivedToday,
+                    bounced: Math.floor(stats.sentToday * stats.bounceRate / 100),
+                    queued: stats.queueSize,
+                    failed: 0,
+                    averageDeliveryTime: 0,
+                    deliveryRate: stats.deliveryRate,
+                    bounceRate: stats.bounceRate,
+                },
+                domainBreakdown: dataArg.includeDetails ? stats.domainBreakdown : undefined,
+            };
+        }));
+        // DNS Statistics Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getDnsStatistics', async (dataArg, toolsArg) => {
+            const dnsServer = this.opsServerRef.dcRouterRef.dnsServer;
+            if (!dnsServer) {
+                return {
+                    stats: {
+                        totalQueries: 0,
+                        cacheHits: 0,
+                        cacheMisses: 0,
+                        cacheHitRate: 0,
+                        activeDomains: 0,
+                        averageResponseTime: 0,
+                        queryTypes: {},
+                    },
+                };
+            }
+            const stats = await this.collectDnsStats();
+            return {
+                stats: {
+                    totalQueries: stats.totalQueries,
+                    cacheHits: stats.cacheHits,
+                    cacheMisses: stats.cacheMisses,
+                    cacheHitRate: stats.cacheHitRate,
+                    activeDomains: stats.topDomains.length,
+                    averageResponseTime: 0,
+                    queryTypes: stats.queryTypes,
+                },
+                domainBreakdown: dataArg.includeQueryTypes ? stats.domainBreakdown : undefined,
+            };
+        }));
+        // Queue Status Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getQueueStatus', async (dataArg, toolsArg) => {
+            const emailServer = this.opsServerRef.dcRouterRef.emailServer;
+            const queues = [];
+            if (emailServer) {
+                const status = await this.getQueueStatus();
+                queues.push({
+                    name: dataArg.queueName || 'default',
+                    size: status.pending,
+                    processing: status.active,
+                    failed: status.failed,
+                    retrying: status.retrying,
+                    averageProcessingTime: 0,
+                });
+            }
+            return {
+                queues,
+                totalItems: queues.reduce((sum, q) => sum + q.size + q.processing + q.failed + q.retrying, 0),
+            };
+        }));
+        // Health Status Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getHealthStatus', async (dataArg, toolsArg) => {
+            const health = await this.checkHealthStatus();
+            return {
+                health: {
+                    healthy: health.healthy,
+                    uptime: process.uptime(),
+                    services: health.services.reduce((acc, service) => {
+                        acc[service.name] = {
+                            status: service.status,
+                            message: service.message,
+                            lastCheck: Date.now(),
+                        };
+                        return acc;
+                    }, {}),
+                    version: '2.12.0', // TODO: Get from package.json
+                },
+            };
+        }));
+        // Combined Metrics Handler - More efficient for frontend polling
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getCombinedMetrics', async (dataArg, toolsArg) => {
+            const sections = dataArg.sections || {
+                server: true,
+                email: true,
+                dns: true,
+                security: true,
+                network: true,
+            };
+            const metrics = {};
+            // Run all metrics collection in parallel
+            const promises = [];
+            if (sections.server) {
+                promises.push(this.collectServerStats().then(stats => {
+                    metrics.server = {
+                        uptime: stats.uptime,
+                        startTime: Date.now() - (stats.uptime * 1000),
+                        memoryUsage: stats.memoryUsage,
+                        cpuUsage: stats.cpuUsage,
+                        activeConnections: stats.activeConnections,
+                        totalConnections: stats.totalConnections,
+                        requestsPerSecond: stats.requestsPerSecond,
+                        throughput: stats.throughput,
+                    };
+                }));
+            }
+            if (sections.email) {
+                promises.push(this.collectEmailStats().then(stats => {
+                    // Get time-series data from MetricsManager
+                    const timeSeries = this.opsServerRef.dcRouterRef.metricsManager
+                        ? this.opsServerRef.dcRouterRef.metricsManager.getEmailTimeSeries(24)
+                        : undefined;
+                    metrics.email = {
+                        sent: stats.sentToday,
+                        received: stats.receivedToday,
+                        bounced: Math.floor(stats.sentToday * stats.bounceRate / 100),
+                        queued: stats.queueSize,
+                        failed: 0,
+                        averageDeliveryTime: 0,
+                        deliveryRate: stats.deliveryRate,
+                        bounceRate: stats.bounceRate,
+                        timeSeries,
+                    };
+                }));
+            }
+            if (sections.dns) {
+                promises.push(this.collectDnsStats().then(stats => {
+                    // Get time-series data from MetricsManager
+                    const timeSeries = this.opsServerRef.dcRouterRef.metricsManager
+                        ? this.opsServerRef.dcRouterRef.metricsManager.getDnsTimeSeries(24)
+                        : undefined;
+                    metrics.dns = {
+                        totalQueries: stats.totalQueries,
+                        cacheHits: stats.cacheHits,
+                        cacheMisses: stats.cacheMisses,
+                        cacheHitRate: stats.cacheHitRate,
+                        activeDomains: stats.topDomains.length,
+                        averageResponseTime: 0,
+                        queryTypes: stats.queryTypes,
+                        timeSeries,
+                        recentQueries: stats.recentQueries,
+                    };
+                }));
+            }
+            if (sections.security && this.opsServerRef.dcRouterRef.metricsManager) {
+                promises.push(this.opsServerRef.dcRouterRef.metricsManager.getSecurityStats().then(stats => {
+                    // Get recent events from the SecurityLogger singleton
+                    const securityLogger = SecurityLogger.getInstance();
+                    const recentEvents = securityLogger.getRecentEvents(50).map((evt) => ({
+                        timestamp: evt.timestamp,
+                        level: evt.level,
+                        type: evt.type,
+                        message: evt.message,
+                        details: evt.details,
+                        ipAddress: evt.ipAddress,
+                        domain: evt.domain,
+                        success: evt.success,
+                    }));
+                    metrics.security = {
+                        blockedIPs: stats.blockedIPs,
+                        reputationScores: {},
+                        spamDetected: stats.spamDetected,
+                        malwareDetected: stats.malwareDetected,
+                        phishingDetected: stats.phishingDetected,
+                        authenticationFailures: stats.authFailures,
+                        suspiciousActivities: stats.totalThreatsBlocked,
+                        recentEvents,
+                    };
+                }));
+            }
+            if (sections.network && this.opsServerRef.dcRouterRef.metricsManager) {
+                promises.push((async () => {
+                    const stats = await this.opsServerRef.dcRouterRef.metricsManager.getNetworkStats();
+                    const serverStats = await this.collectServerStats();
+                    // Build per-IP bandwidth lookup from throughputByIP
+                    const ipBandwidth = new Map();
+                    if (stats.throughputByIP) {
+                        for (const [ip, tp] of stats.throughputByIP) {
+                            ipBandwidth.set(ip, { in: tp.in, out: tp.out });
+                        }
+                    }
+                    metrics.network = {
+                        totalBandwidth: {
+                            in: stats.throughputRate.bytesInPerSecond,
+                            out: stats.throughputRate.bytesOutPerSecond,
+                        },
+                        totalBytes: {
+                            in: stats.totalDataTransferred.bytesIn,
+                            out: stats.totalDataTransferred.bytesOut,
+                        },
+                        activeConnections: serverStats.activeConnections,
+                        connectionDetails: [],
+                        topEndpoints: stats.topIPs.map(ip => ({
+                            endpoint: ip.ip,
+                            requests: ip.count,
+                            bandwidth: ipBandwidth.get(ip.ip) || { in: 0, out: 0 },
+                        })),
+                        throughputHistory: stats.throughputHistory || [],
+                        requestsPerSecond: stats.requestsPerSecond || 0,
+                        requestsTotal: stats.requestsTotal || 0,
+                    };
+                })());
+            }
+            await Promise.all(promises);
+            return {
+                metrics,
+                timestamp: Date.now(),
+            };
+        }));
+    }
+    async collectServerStats() {
+        // Get metrics from MetricsManager if available
+        if (this.opsServerRef.dcRouterRef.metricsManager) {
+            const serverStats = await this.opsServerRef.dcRouterRef.metricsManager.getServerStats();
+            return {
+                uptime: serverStats.uptime,
+                cpuUsage: serverStats.cpuUsage,
+                memoryUsage: serverStats.memoryUsage,
+                requestsPerSecond: serverStats.requestsPerSecond,
+                activeConnections: serverStats.activeConnections,
+                totalConnections: serverStats.totalConnections,
+                throughput: serverStats.throughput,
+                history: [], // TODO: Implement history tracking
+            };
+        }
+        // Fallback to basic stats if MetricsManager not available
+        const uptime = process.uptime();
+        const memUsage = process.memoryUsage();
+        const cpuUsage = plugins.os.loadavg()[0] * 100 / plugins.os.cpus().length;
+        return {
+            uptime,
+            cpuUsage: {
+                user: cpuUsage * 0.7,
+                system: cpuUsage * 0.3,
+            },
+            memoryUsage: {
+                heapUsed: memUsage.heapUsed,
+                heapTotal: memUsage.heapTotal,
+                external: memUsage.external,
+                rss: memUsage.rss,
+            },
+            requestsPerSecond: 0,
+            activeConnections: 0,
+            totalConnections: 0,
+            throughput: { bytesIn: 0, bytesOut: 0, bytesInPerSecond: 0, bytesOutPerSecond: 0 },
+            history: [],
+        };
+    }
+    async collectEmailStats() {
+        // Get metrics from MetricsManager if available
+        if (this.opsServerRef.dcRouterRef.metricsManager) {
+            const emailStats = await this.opsServerRef.dcRouterRef.metricsManager.getEmailStats();
+            return {
+                sentToday: emailStats.sentToday,
+                receivedToday: emailStats.receivedToday,
+                bounceRate: emailStats.bounceRate,
+                deliveryRate: emailStats.deliveryRate,
+                queueSize: emailStats.queueSize,
+            };
+        }
+        // Fallback if MetricsManager not available
+        return {
+            sentToday: 0,
+            receivedToday: 0,
+            bounceRate: 0,
+            deliveryRate: 100,
+            queueSize: 0,
+        };
+    }
+    async collectDnsStats() {
+        // Get metrics from MetricsManager if available
+        if (this.opsServerRef.dcRouterRef.metricsManager) {
+            const dnsStats = await this.opsServerRef.dcRouterRef.metricsManager.getDnsStats();
+            return {
+                queriesPerSecond: dnsStats.queriesPerSecond,
+                totalQueries: dnsStats.totalQueries,
+                cacheHits: dnsStats.cacheHits,
+                cacheMisses: dnsStats.cacheMisses,
+                cacheHitRate: dnsStats.cacheHitRate,
+                topDomains: dnsStats.topDomains,
+                queryTypes: dnsStats.queryTypes,
+                recentQueries: dnsStats.recentQueries,
+            };
+        }
+        // Fallback if MetricsManager not available
+        return {
+            queriesPerSecond: 0,
+            totalQueries: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            cacheHitRate: 0,
+            topDomains: [],
+            queryTypes: {},
+        };
+    }
+    async getQueueStatus() {
+        // TODO: Implement actual queue status collection
+        return {
+            pending: 0,
+            active: 0,
+            failed: 0,
+            retrying: 0,
+            items: [],
+        };
+    }
+    async checkHealthStatus() {
+        const services = [];
+        // Check HTTP Proxy
+        if (this.opsServerRef.dcRouterRef.smartProxy) {
+            services.push({
+                name: 'HTTP/HTTPS Proxy',
+                status: 'healthy',
+            });
+        }
+        // Check Email Server
+        if (this.opsServerRef.dcRouterRef.emailServer) {
+            services.push({
+                name: 'Email Server',
+                status: 'healthy',
+            });
+        }
+        // Check DNS Server
+        if (this.opsServerRef.dcRouterRef.dnsServer) {
+            services.push({
+                name: 'DNS Server',
+                status: 'healthy',
+            });
+        }
+        // Check OpsServer
+        services.push({
+            name: 'OpsServer',
+            status: 'healthy',
+        });
+        const healthy = services.every(s => s.status === 'healthy');
+        return {
+            healthy,
+            services,
+            checks: [
+                {
+                    name: 'Memory Usage',
+                    passed: process.memoryUsage().heapUsed < (plugins.os.totalmem() * 0.9),
+                    message: 'Memory usage within limits',
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stats.handler.js","sourceRoot":"","sources":["../../../../ts/opsserver/handlers/stats.handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/security/classes.securitylogger.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Log level for security events
+ */
+export declare enum SecurityLogLevel {
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error",
+    CRITICAL = "critical"
+}
+/**
+ * Security event types for categorization
+ */
+export declare enum SecurityEventType {
+    AUTHENTICATION = "authentication",
+    ACCESS_CONTROL = "access_control",
+    EMAIL_VALIDATION = "email_validation",
+    EMAIL_PROCESSING = "email_processing",
+    EMAIL_FORWARDING = "email_forwarding",
+    EMAIL_DELIVERY = "email_delivery",
+    DKIM = "dkim",
+    SPF = "spf",
+    DMARC = "dmarc",
+    RATE_LIMIT = "rate_limit",
+    RATE_LIMITING = "rate_limiting",
+    SPAM = "spam",
+    MALWARE = "malware",
+    CONNECTION = "connection",
+    DATA_EXPOSURE = "data_exposure",
+    CONFIGURATION = "configuration",
+    IP_REPUTATION = "ip_reputation",
+    REJECTED_CONNECTION = "rejected_connection"
+}
+/**
+ * Security event interface
+ */
+export interface ISecurityEvent {
+    timestamp: number;
+    level: SecurityLogLevel;
+    type: SecurityEventType;
+    message: string;
+    details?: any;
+    ipAddress?: string;
+    userId?: string;
+    sessionId?: string;
+    emailId?: string;
+    domain?: string;
+    action?: string;
+    result?: string;
+    success?: boolean;
+}
+/**
+ * Security logger for enhanced security monitoring
+ */
+export declare class SecurityLogger {
+    private static instance;
+    private securityEvents;
+    private maxEventHistory;
+    private enableNotifications;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(options?: {
+        maxEventHistory?: number;
+        enableNotifications?: boolean;
+    }): SecurityLogger;
+    /**
+     * Log a security event
+     * @param event The security event to log
+     */
+    logEvent(event: Omit<ISecurityEvent, 'timestamp'>): void;
+    /**
+     * Get recent security events
+     * @param limit Maximum number of events to return
+     * @param filter Filter for specific event types
+     * @returns Recent security events
+     */
+    getRecentEvents(limit?: number, filter?: {
+        level?: SecurityLogLevel;
+        type?: SecurityEventType;
+        fromTimestamp?: number;
+        toTimestamp?: number;
+    }): ISecurityEvent[];
+    /**
+     * Get events by security level
+     * @param level The security level to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events matching the level
+     */
+    getEventsByLevel(level: SecurityLogLevel, limit?: number): ISecurityEvent[];
+    /**
+     * Get events by security type
+     * @param type The event type to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events matching the type
+     */
+    getEventsByType(type: SecurityEventType, limit?: number): ISecurityEvent[];
+    /**
+     * Get security events for a specific IP address
+     * @param ipAddress The IP address to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events for the IP address
+     */
+    getEventsByIP(ipAddress: string, limit?: number): ISecurityEvent[];
+    /**
+     * Get security events for a specific domain
+     * @param domain The domain to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events for the domain
+     */
+    getEventsByDomain(domain: string, limit?: number): ISecurityEvent[];
+    /**
+     * Send a notification for critical security events
+     * @param event The security event to notify about
+     * @private
+     */
+    private sendNotification;
+    /**
+     * Clear event history
+     */
+    clearEvents(): void;
+    /**
+     * Get statistical summary of security events
+     * @param timeWindow Optional time window in milliseconds
+     * @returns Summary of security events
+     */
+    getEventsSummary(timeWindow?: number): {
+        total: number;
+        byLevel: Record<SecurityLogLevel, number>;
+        byType: Record<SecurityEventType, number>;
+        topIPs: Array<{
+            ip: string;
+            count: number;
+        }>;
+        topDomains: Array<{
+            domain: string;
+            count: number;
+        }>;
+    };
+}

package/dist_ts_interfaces/requests/config.d.ts

@@ -1,5 +1,81 @@
 import * as plugins from '../plugins.js';
 import * as authInterfaces from '../data/auth.js';
+export interface IConfigData {
+    system: {
+        baseDir: string;
+        dataDir: string;
+        publicIp: string | null;
+        proxyIps: string[];
+        uptime: number;
+        storageBackend: 'filesystem' | 'custom' | 'memory';
+        storagePath: string | null;
+    };
+    smartProxy: {
+        enabled: boolean;
+        routeCount: number;
+        acme: {
+            enabled: boolean;
+            accountEmail: string;
+            useProduction: boolean;
+            autoRenew: boolean;
+            renewThresholdDays: number;
+        } | null;
+    };
+    email: {
+        enabled: boolean;
+        ports: number[];
+        portMapping: Record<string, number> | null;
+        hostname: string | null;
+        domains: string[];
+        emailRouteCount: number;
+        receivedEmailsPath: string | null;
+    };
+    dns: {
+        enabled: boolean;
+        port: number;
+        nsDomains: string[];
+        scopes: string[];
+        recordCount: number;
+        records: Array<{
+            name: string;
+            type: string;
+            value: string;
+            ttl?: number;
+        }>;
+        dnsChallenge: boolean;
+    };
+    tls: {
+        contactEmail: string | null;
+        domain: string | null;
+        source: 'acme' | 'static' | 'none';
+        certPath: string | null;
+        keyPath: string | null;
+    };
+    cache: {
+        enabled: boolean;
+        storagePath: string | null;
+        dbName: string | null;
+        defaultTTLDays: number;
+        cleanupIntervalHours: number;
+        ttlConfig: Record<string, number>;
+    };
+    radius: {
+        enabled: boolean;
+        authPort: number | null;
+        acctPort: number | null;
+        bindAddress: string | null;
+        clientCount: number;
+        vlanDefaultVlan: number | null;
+        vlanAllowUnknownMacs: boolean | null;
+        vlanMappingCount: number;
+    };
+    remoteIngress: {
+        enabled: boolean;
+        tunnelPort: number | null;
+        hubDomain: string | null;
+        tlsConfigured: boolean;
+    };
+}
 export interface IReq_GetConfiguration extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_GetConfiguration> {
     method: 'getConfiguration';
     request: {
@@ -7,7 +83,7 @@ export interface IReq_GetConfiguration extends plugins.typedrequestInterfaces.im
         section?: string;
     };
     response: {
-        config: any;
+        config: IConfigData;
         section?: string;
     };
 }

package/dist_ts_web/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/dcrouter',
-    version: '8.1.0',
+    version: '9.1.0',
     description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsc0JBQXNCO0lBQzVCLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSwwRUFBMEU7Q0FDeEYsQ0FBQSJ9

package/dist_ts_web/appstate.d.ts

@@ -15,7 +15,7 @@ export interface IStatsState {
     error: string | null;
 }
 export interface IConfigState {
-    config: any | null;
+    config: interfaces.requests.IConfigData | null;
     isLoading: boolean;
     error: string | null;
 }