@serve.zone/dcrouter 13.17.0 → 13.17.2

package/dist_ts/http3/http3-route-augmentation.js

@@ -0,0 +1,98 @@
+/**
+ * Check whether a TPortRange includes port 443.
+ */
+function portRangeIncludes443(ports) {
+    if (typeof ports === 'number')
+        return ports === 443;
+    if (Array.isArray(ports)) {
+        return ports.some((p) => {
+            if (typeof p === 'number')
+                return p === 443;
+            return p.from <= 443 && p.to >= 443;
+        });
+    }
+    return false;
+}
+/**
+ * Check if a route name indicates an email route that should not get HTTP/3.
+ */
+function isEmailRoute(route) {
+    const name = route.name?.toLowerCase() || '';
+    return (name.startsWith('smtp-') ||
+        name.startsWith('submission-') ||
+        name.startsWith('smtps-') ||
+        name.startsWith('email-'));
+}
+/**
+ * Determine if a route qualifies for HTTP/3 augmentation.
+ */
+export function routeQualifiesForHttp3(route, globalConfig) {
+    // Check global enable + per-route override
+    const globalEnabled = globalConfig.enabled !== false; // default true
+    const perRouteOverride = route.action.options?.http3;
+    // If per-route explicitly set, use that; otherwise use global
+    const shouldAugment = perRouteOverride !== undefined ? perRouteOverride : globalEnabled;
+    if (!shouldAugment)
+        return false;
+    // Must be forward type
+    if (route.action.type !== 'forward')
+        return false;
+    // Must include port 443
+    if (!portRangeIncludes443(route.match.ports))
+        return false;
+    // Must have TLS
+    if (!route.action.tls)
+        return false;
+    // Skip email routes
+    if (isEmailRoute(route))
+        return false;
+    // Skip if already configured with transport 'all' or 'udp'
+    if (route.match.transport === 'all' || route.match.transport === 'udp')
+        return false;
+    // Skip if already has QUIC config
+    if (route.action.udp?.quic)
+        return false;
+    return true;
+}
+/**
+ * Augment a single route with HTTP/3 fields.
+ * Returns a new route object (does not mutate the original).
+ */
+export function augmentRouteWithHttp3(route, config) {
+    if (!routeQualifiesForHttp3(route, config)) {
+        return route;
+    }
+    return {
+        ...route,
+        match: {
+            ...route.match,
+            transport: 'all',
+        },
+        action: {
+            ...route.action,
+            udp: {
+                ...(route.action.udp || {}),
+                sessionTimeout: config.udpSettings?.sessionTimeout,
+                maxSessionsPerIP: config.udpSettings?.maxSessionsPerIP,
+                maxDatagramSize: config.udpSettings?.maxDatagramSize,
+                quic: {
+                    enableHttp3: true,
+                    maxIdleTimeout: config.quicSettings?.maxIdleTimeout,
+                    maxConcurrentBidiStreams: config.quicSettings?.maxConcurrentBidiStreams,
+                    maxConcurrentUniStreams: config.quicSettings?.maxConcurrentUniStreams,
+                    altSvcPort: config.altSvc?.port,
+                    altSvcMaxAge: config.altSvc?.maxAge ?? 86400,
+                    initialCongestionWindow: config.quicSettings?.initialCongestionWindow,
+                },
+            },
+        },
+    };
+}
+/**
+ * Augment all qualifying routes in an array.
+ * Returns a new array (does not mutate originals).
+ */
+export function augmentRoutesWithHttp3(routes, config) {
+    return routes.map((route) => augmentRouteWithHttp3(route, config));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/http3/index.d.ts

@@ -0,0 +1 @@
+export * from './http3-route-augmentation.js';

package/dist_ts/http3/index.js

@@ -0,0 +1,2 @@
+export * from './http3-route-augmentation.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9odHRwMy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1,8 @@
+export * from './00_commitinfo_data.js';
+export { UnifiedEmailServer } from '@push.rocks/smartmta';
+export type { IUnifiedEmailServerOptions, IEmailRoute, IEmailDomainConfig } from '@push.rocks/smartmta';
+export * from './classes.dcrouter.js';
+export * from './radius/index.js';
+export * from './remoteingress/index.js';
+export type { IHttp3Config } from './http3/index.js';
+export declare const runCli: () => Promise<void>;

package/dist_ts/index.js

@@ -0,0 +1,29 @@
+export * from './00_commitinfo_data.js';
+// Re-export smartmta (excluding commitinfo to avoid naming conflict)
+export { UnifiedEmailServer } from '@push.rocks/smartmta';
+// DcRouter
+import { DcRouter } from './classes.dcrouter.js';
+export * from './classes.dcrouter.js';
+// RADIUS module
+export * from './radius/index.js';
+// Remote Ingress module
+export * from './remoteingress/index.js';
+export const runCli = async () => {
+    let options = {};
+    if (process.env.DCROUTER_MODE === 'OCI_CONTAINER') {
+        const { getOciContainerConfig } = await import('../dist_ts_oci_container/index.js');
+        options = getOciContainerConfig();
+        console.log('[DCRouter] Starting in OCI Container mode...');
+    }
+    const dcRouter = new DcRouter(options);
+    await dcRouter.start();
+    console.log('[DCRouter] Running. Send SIGTERM or SIGINT to stop.');
+    const shutdown = async () => {
+        console.log('[DCRouter] Shutting down...');
+        await dcRouter.stop();
+        process.exit(0);
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBRXhDLHFFQUFxRTtBQUNyRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUcxRCxXQUFXO0FBQ1gsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ2pELGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsZ0JBQWdCO0FBQ2hCLGNBQWMsbUJBQW1CLENBQUM7QUFFbEMsd0JBQXdCO0FBQ3hCLGNBQWMsMEJBQTBCLENBQUM7QUFLekMsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLEtBQUssSUFBSSxFQUFFO0lBQy9CLElBQUksT0FBTyxHQUFxRCxFQUFFLENBQUM7SUFFbkUsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLGFBQWEsS0FBSyxlQUFlLEVBQUUsQ0FBQztRQUNsRCxNQUFNLEVBQUUscUJBQXFCLEVBQUUsR0FBRyxNQUFNLE1BQU0sQ0FBQyw4QkFBOEIsQ0FBQyxDQUFDO1FBQy9FLE9BQU8sR0FBRyxxQkFBcUIsRUFBRSxDQUFDO1FBQ2xDLE9BQU8sQ0FBQyxHQUFHLENBQUMsOENBQThDLENBQUMsQ0FBQztJQUM5RCxDQUFDO0lBRUQsTUFBTSxRQUFRLEdBQUcsSUFBSSxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDdkMsTUFBTSxRQUFRLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDdkIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxxREFBcUQsQ0FBQyxDQUFDO0lBRW5FLE1BQU0sUUFBUSxHQUFHLEtBQUssSUFBSSxFQUFFO1FBQzFCLE9BQU8sQ0FBQyxHQUFHLENBQUMsNkJBQTZCLENBQUMsQ0FBQztRQUMzQyxNQUFNLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUN0QixPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2xCLENBQUMsQ0FBQztJQUNGLE9BQU8sQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ2pDLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLFFBQVEsQ0FBQyxDQUFDO0FBQ3BDLENBQUMsQ0FBQyJ9

package/dist_ts/logger.d.ts

@@ -0,0 +1,21 @@
+import * as plugins from './plugins.js';
+import { SmartlogDestinationBuffer } from '@push.rocks/smartlog/destination-buffer';
+export declare const logBuffer: SmartlogDestinationBuffer;
+export declare const baseLogger: plugins.smartlog.Smartlog;
+declare class StandardLogger {
+    private defaultContext;
+    private correlationId;
+    constructor();
+    log(level: 'error' | 'warn' | 'info' | 'success' | 'debug', message: string, context?: Record<string, any>): void;
+    error(message: string, context?: Record<string, any>): void;
+    warn(message: string, context?: Record<string, any>): void;
+    info(message: string, context?: Record<string, any>): void;
+    success(message: string, context?: Record<string, any>): void;
+    debug(message: string, context?: Record<string, any>): void;
+    setContext(context: Record<string, any>, overwrite?: boolean): void;
+    setCorrelationId(id?: string | null): string;
+    getCorrelationId(): string | null;
+    clearCorrelationId(): void;
+}
+export declare const logger: StandardLogger;
+export {};

package/dist_ts/logger.js

@@ -0,0 +1,81 @@
+import * as plugins from './plugins.js';
+import { randomUUID } from 'node:crypto';
+import { SmartlogDestinationBuffer } from '@push.rocks/smartlog/destination-buffer';
+// Map NODE_ENV to valid TEnvironment
+const nodeEnv = process.env.NODE_ENV || 'production';
+const envMap = {
+    'development': 'local',
+    'test': 'test',
+    'staging': 'staging',
+    'production': 'production'
+};
+// In-memory log buffer for the OpsServer UI
+export const logBuffer = new SmartlogDestinationBuffer({ maxEntries: 2000 });
+// Default Smartlog instance (exported so OpsServer can add push destinations)
+export const baseLogger = new plugins.smartlog.Smartlog({
+    logContext: {
+        environment: envMap[nodeEnv] || 'production',
+        runtime: 'node',
+        zone: 'serve.zone',
+    }
+});
+// Wire the buffer destination so all logs are captured
+baseLogger.addLogDestination(logBuffer);
+// Extended logger compatible with the original enhanced logger API
+class StandardLogger {
+    defaultContext = {};
+    correlationId = null;
+    constructor() { }
+    // Log methods
+    log(level, message, context = {}) {
+        const combinedContext = {
+            ...this.defaultContext,
+            ...context
+        };
+        if (this.correlationId) {
+            combinedContext.correlation_id = this.correlationId;
+        }
+        baseLogger.log(level, message, combinedContext);
+    }
+    error(message, context = {}) {
+        this.log('error', message, context);
+    }
+    warn(message, context = {}) {
+        this.log('warn', message, context);
+    }
+    info(message, context = {}) {
+        this.log('info', message, context);
+    }
+    success(message, context = {}) {
+        this.log('success', message, context);
+    }
+    debug(message, context = {}) {
+        this.log('debug', message, context);
+    }
+    // Context management
+    setContext(context, overwrite = false) {
+        if (overwrite) {
+            this.defaultContext = context;
+        }
+        else {
+            this.defaultContext = {
+                ...this.defaultContext,
+                ...context
+            };
+        }
+    }
+    // Correlation ID management
+    setCorrelationId(id = null) {
+        this.correlationId = id || randomUUID();
+        return this.correlationId;
+    }
+    getCorrelationId() {
+        return this.correlationId;
+    }
+    clearCorrelationId() {
+        this.correlationId = null;
+    }
+}
+// Export a singleton instance
+export const logger = new StandardLogger();
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/monitoring/classes.metricscache.d.ts

@@ -0,0 +1,32 @@
+export interface ICacheEntry<T> {
+    data: T;
+    timestamp: number;
+}
+export declare class MetricsCache {
+    private cache;
+    private readonly defaultTTL;
+    constructor(defaultTTL?: number);
+    /**
+     * Get cached data or compute and cache it
+     */
+    get<T>(key: string, computeFn: () => T | Promise<T>, ttl?: number): T | Promise<T>;
+    /**
+     * Invalidate a specific cache entry
+     */
+    invalidate(key: string): void;
+    /**
+     * Clear all cache entries
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        keys: string[];
+    };
+    /**
+     * Clean up expired entries
+     */
+    cleanup(): void;
+}

package/dist_ts/monitoring/classes.metricscache.js

@@ -0,0 +1,63 @@
+export class MetricsCache {
+    cache = new Map();
+    defaultTTL;
+    constructor(defaultTTL = 500) {
+        this.defaultTTL = defaultTTL;
+    }
+    /**
+     * Get cached data or compute and cache it
+     */
+    get(key, computeFn, ttl) {
+        const cached = this.cache.get(key);
+        const now = Date.now();
+        const actualTTL = ttl ?? this.defaultTTL;
+        if (cached && (now - cached.timestamp) < actualTTL) {
+            return cached.data;
+        }
+        const result = computeFn();
+        // Handle both sync and async compute functions
+        if (result instanceof Promise) {
+            return result.then(data => {
+                this.cache.set(key, { data, timestamp: now });
+                return data;
+            });
+        }
+        else {
+            this.cache.set(key, { data: result, timestamp: now });
+            return result;
+        }
+    }
+    /**
+     * Invalidate a specific cache entry
+     */
+    invalidate(key) {
+        this.cache.delete(key);
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return {
+            size: this.cache.size,
+            keys: Array.from(this.cache.keys())
+        };
+    }
+    /**
+     * Clean up expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.defaultTTL) {
+                this.cache.delete(key);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/monitoring/classes.metricsmanager.d.ts

@@ -0,0 +1,235 @@
+import { DcRouter } from '../classes.dcrouter.js';
+export declare class MetricsManager {
+    private metricsLogger;
+    private smartMetrics;
+    private dcRouter;
+    private resetInterval?;
+    private metricsCache;
+    private readonly MAX_TOP_DOMAINS;
+    private emailMetrics;
+    private dnsMetrics;
+    private emailMinuteBuckets;
+    private dnsMinuteBuckets;
+    private securityMetrics;
+    constructor(dcRouter: DcRouter);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getServerStats(): Promise<{
+        uptime: number;
+        startTime: number;
+        memoryUsage: {
+            heapUsed: number;
+            heapTotal: number;
+            external: number;
+            rss: number;
+            maxMemoryMB: number;
+            actualUsageBytes: number;
+            actualUsagePercentage: number;
+        };
+        cpuUsage: {
+            user: number;
+            system: number;
+        };
+        activeConnections: any;
+        totalConnections: number;
+        requestsPerSecond: number;
+        throughput: {
+            bytesIn: number;
+            bytesOut: number;
+            bytesInPerSecond: number;
+            bytesOutPerSecond: number;
+        };
+    }>;
+    getEmailStats(): Promise<{
+        sentToday: number;
+        receivedToday: number;
+        failedToday: number;
+        bounceRate: number;
+        deliveryRate: number;
+        queueSize: number;
+        averageDeliveryTime: number;
+        topRecipients: {
+            email: string;
+            count: number;
+        }[];
+        recentActivity: {
+            timestamp: number;
+            type: string;
+            details: string;
+        }[];
+    }>;
+    getDnsStats(): Promise<{
+        queriesPerSecond: number;
+        totalQueries: number;
+        cacheHits: number;
+        cacheMisses: number;
+        cacheHitRate: number;
+        topDomains: {
+            domain: string;
+            count: number;
+        }[];
+        queryTypes: Record<string, number>;
+        averageResponseTime: number;
+        activeDomains: number;
+        recentQueries: {
+            timestamp: number;
+            domain: string;
+            type: string;
+            answered: boolean;
+            responseTimeMs: number;
+        }[];
+    }>;
+    /**
+     * Sync security metrics from the SecurityLogger singleton (last 24h).
+     * Called before returning security stats so counters reflect real events.
+     */
+    private syncFromSecurityLogger;
+    getSecurityStats(): Promise<{
+        blockedIPs: number;
+        authFailures: number;
+        spamDetected: number;
+        malwareDetected: number;
+        phishingDetected: number;
+        totalThreatsBlocked: number;
+        recentIncidents: {
+            timestamp: number;
+            type: string;
+            severity: string;
+            details: string;
+        }[];
+    }>;
+    getConnectionInfo(): Promise<{
+        type: string;
+        count: number;
+        source: string;
+        lastActivity: Date;
+    }[]>;
+    trackEmailSent(recipient?: string, deliveryTimeMs?: number): void;
+    trackEmailReceived(sender?: string): void;
+    trackEmailFailed(recipient?: string, reason?: string): void;
+    trackEmailBounced(recipient?: string): void;
+    updateQueueSize(size: number): void;
+    trackDnsQuery(queryType: string, domain: string, cacheHit: boolean, responseTimeMs?: number, answered?: boolean): void;
+    trackBlockedIP(ip?: string, reason?: string): void;
+    trackAuthFailure(username?: string, ip?: string): void;
+    trackSpamDetected(sender?: string): void;
+    trackMalwareDetected(source?: string): void;
+    trackPhishingDetected(source?: string): void;
+    getNetworkStats(): Promise<{
+        connectionsByIP: Map<string, number>;
+        throughputRate: {
+            bytesInPerSecond: number;
+            bytesOutPerSecond: number;
+        };
+        topIPs: Array<{
+            ip: string;
+            count: number;
+        }>;
+        topIPsByBandwidth: Array<{
+            ip: string;
+            count: number;
+            bwIn: number;
+            bwOut: number;
+        }>;
+        totalDataTransferred: {
+            bytesIn: number;
+            bytesOut: number;
+        };
+        throughputHistory: Array<{
+            timestamp: number;
+            in: number;
+            out: number;
+        }>;
+        throughputByIP: Map<string, {
+            in: number;
+            out: number;
+        }>;
+        requestsPerSecond: number;
+        requestsTotal: number;
+        backends: Array<any>;
+        domainActivity: Array<{
+            domain: string;
+            bytesInPerSecond: number;
+            bytesOutPerSecond: number;
+            activeConnections: number;
+            routeCount: number;
+            requestCount: number;
+        }>;
+        frontendProtocols?: undefined;
+        backendProtocols?: undefined;
+    } | {
+        connectionsByIP: Map<string, number>;
+        throughputRate: {
+            bytesInPerSecond: number;
+            bytesOutPerSecond: number;
+        };
+        topIPs: {
+            ip: string;
+            count: number;
+        }[];
+        topIPsByBandwidth: {
+            ip: string;
+            count: number;
+            bwIn: number;
+            bwOut: number;
+        }[];
+        totalDataTransferred: {
+            bytesIn: number;
+            bytesOut: number;
+        };
+        throughputHistory: import("@push.rocks/smartproxy/dist_ts/proxies/smart-proxy/index.js").IThroughputHistoryPoint[];
+        throughputByIP: Map<string, import("@push.rocks/smartproxy/dist_ts/proxies/smart-proxy/index.js").IThroughputData>;
+        requestsPerSecond: number;
+        requestsTotal: number;
+        backends: any[];
+        frontendProtocols: import("@push.rocks/smartproxy/dist_ts/proxies/smart-proxy/index.js").IProtocolDistribution;
+        backendProtocols: import("@push.rocks/smartproxy/dist_ts/proxies/smart-proxy/index.js").IProtocolDistribution;
+        domainActivity: {
+            domain: string;
+            bytesInPerSecond: number;
+            bytesOutPerSecond: number;
+            activeConnections: number;
+            routeCount: number;
+            requestCount: number;
+        }[];
+    }>;
+    private static minuteKey;
+    private incrementEmailBucket;
+    private incrementDnsBucket;
+    /**
+     * Increment the per-second query counter in the ring buffer.
+     * Zeros any stale slots between the last write and the current second.
+     */
+    private incrementQueryRing;
+    /**
+     * Sum query counts from the ring buffer for the last N seconds.
+     */
+    private getQueryRingSum;
+    private pruneOldBuckets;
+    /**
+     * Get email time-series data for the last N hours, aggregated per minute.
+     */
+    getEmailTimeSeries(hours?: number): {
+        sent: Array<{
+            timestamp: number;
+            value: number;
+        }>;
+        received: Array<{
+            timestamp: number;
+            value: number;
+        }>;
+        failed: Array<{
+            timestamp: number;
+            value: number;
+        }>;
+    };
+    /**
+     * Get DNS time-series data for the last N hours, aggregated per minute.
+     */
+    getDnsTimeSeries(hours?: number): {
+        queries: Array<{
+            timestamp: number;
+            value: number;
+        }>;
+    };
+}