@serve.zone/dcrouter 2.12.4 → 5.0.3

package/dist_ts/monitoring/classes.metricsmanager.js

@@ -0,0 +1,446 @@
+import * as plugins from '../plugins.js';
+import { DcRouter } from '../classes.dcrouter.js';
+import { MetricsCache } from './classes.metricscache.js';
+export class MetricsManager {
+    logger;
+    smartMetrics;
+    dcRouter;
+    resetInterval;
+    metricsCache;
+    // Constants
+    MAX_TOP_DOMAINS = 1000; // Limit topDomains Map size
+    // Track email-specific metrics
+    emailMetrics = {
+        sentToday: 0,
+        receivedToday: 0,
+        failedToday: 0,
+        bouncedToday: 0,
+        queueSize: 0,
+        lastResetDate: new Date().toDateString(),
+        deliveryTimes: [], // Track delivery times in ms
+        recipients: new Map(), // Track email count by recipient
+        recentActivity: [],
+    };
+    // Track DNS-specific metrics
+    dnsMetrics = {
+        totalQueries: 0,
+        cacheHits: 0,
+        cacheMisses: 0,
+        queryTypes: {},
+        topDomains: new Map(),
+        lastResetDate: new Date().toDateString(),
+        queryTimestamps: [], // Track query timestamps for rate calculation
+        responseTimes: [], // Track response times in ms
+    };
+    // Track security-specific metrics
+    securityMetrics = {
+        blockedIPs: 0,
+        authFailures: 0,
+        spamDetected: 0,
+        malwareDetected: 0,
+        phishingDetected: 0,
+        lastResetDate: new Date().toDateString(),
+        incidents: [],
+    };
+    constructor(dcRouter) {
+        this.dcRouter = dcRouter;
+        // Create a new Smartlog instance for metrics
+        this.logger = new plugins.smartlog.Smartlog({
+            logContext: {
+                environment: 'production',
+                runtime: 'node',
+                zone: 'dcrouter-metrics',
+            }
+        });
+        this.smartMetrics = new plugins.smartmetrics.SmartMetrics(this.logger, 'dcrouter');
+        // Initialize metrics cache with 500ms TTL
+        this.metricsCache = new MetricsCache(500);
+    }
+    async start() {
+        // Start SmartMetrics collection
+        this.smartMetrics.start();
+        // Reset daily counters at midnight
+        this.resetInterval = setInterval(() => {
+            const currentDate = new Date().toDateString();
+            if (currentDate !== this.emailMetrics.lastResetDate) {
+                this.emailMetrics.sentToday = 0;
+                this.emailMetrics.receivedToday = 0;
+                this.emailMetrics.failedToday = 0;
+                this.emailMetrics.bouncedToday = 0;
+                this.emailMetrics.deliveryTimes = [];
+                this.emailMetrics.recipients.clear();
+                this.emailMetrics.recentActivity = [];
+                this.emailMetrics.lastResetDate = currentDate;
+            }
+            if (currentDate !== this.dnsMetrics.lastResetDate) {
+                this.dnsMetrics.totalQueries = 0;
+                this.dnsMetrics.cacheHits = 0;
+                this.dnsMetrics.cacheMisses = 0;
+                this.dnsMetrics.queryTypes = {};
+                this.dnsMetrics.topDomains.clear();
+                this.dnsMetrics.queryTimestamps = [];
+                this.dnsMetrics.responseTimes = [];
+                this.dnsMetrics.lastResetDate = currentDate;
+            }
+            if (currentDate !== this.securityMetrics.lastResetDate) {
+                this.securityMetrics.blockedIPs = 0;
+                this.securityMetrics.authFailures = 0;
+                this.securityMetrics.spamDetected = 0;
+                this.securityMetrics.malwareDetected = 0;
+                this.securityMetrics.phishingDetected = 0;
+                this.securityMetrics.incidents = [];
+                this.securityMetrics.lastResetDate = currentDate;
+            }
+        }, 60000); // Check every minute
+        this.logger.log('info', 'MetricsManager started');
+    }
+    async stop() {
+        // Clear the reset interval
+        if (this.resetInterval) {
+            clearInterval(this.resetInterval);
+            this.resetInterval = undefined;
+        }
+        this.smartMetrics.stop();
+        this.logger.log('info', 'MetricsManager stopped');
+    }
+    // Get server metrics from SmartMetrics and SmartProxy
+    async getServerStats() {
+        return this.metricsCache.get('serverStats', async () => {
+            const smartMetricsData = await this.smartMetrics.getMetrics();
+            const proxyMetrics = this.dcRouter.smartProxy ? this.dcRouter.smartProxy.getMetrics() : null;
+            const proxyStats = this.dcRouter.smartProxy ? await this.dcRouter.smartProxy.getStatistics() : null;
+            return {
+                uptime: process.uptime(),
+                startTime: Date.now() - (process.uptime() * 1000),
+                memoryUsage: {
+                    heapUsed: process.memoryUsage().heapUsed,
+                    heapTotal: process.memoryUsage().heapTotal,
+                    external: process.memoryUsage().external,
+                    rss: process.memoryUsage().rss,
+                    // Add SmartMetrics memory data
+                    maxMemoryMB: this.smartMetrics.maxMemoryMB,
+                    actualUsageBytes: smartMetricsData.memoryUsageBytes,
+                    actualUsagePercentage: smartMetricsData.memoryPercentage,
+                },
+                cpuUsage: {
+                    user: parseFloat(smartMetricsData.cpuUsageText || '0'),
+                    system: 0, // SmartMetrics doesn't separate user/system
+                },
+                activeConnections: proxyStats ? proxyStats.activeConnections : 0,
+                totalConnections: proxyMetrics ? proxyMetrics.totals.connections() : 0,
+                requestsPerSecond: proxyMetrics ? proxyMetrics.requests.perSecond() : 0,
+                throughput: proxyMetrics ? {
+                    bytesIn: proxyMetrics.totals.bytesIn(),
+                    bytesOut: proxyMetrics.totals.bytesOut()
+                } : { bytesIn: 0, bytesOut: 0 },
+            };
+        });
+    }
+    // Get email metrics
+    async getEmailStats() {
+        return this.metricsCache.get('emailStats', () => {
+            // Calculate average delivery time
+            const avgDeliveryTime = this.emailMetrics.deliveryTimes.length > 0
+                ? this.emailMetrics.deliveryTimes.reduce((a, b) => a + b, 0) / this.emailMetrics.deliveryTimes.length
+                : 0;
+            // Get top recipients
+            const topRecipients = Array.from(this.emailMetrics.recipients.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 10)
+                .map(([email, count]) => ({ email, count }));
+            // Get recent activity (last 50 entries)
+            const recentActivity = this.emailMetrics.recentActivity.slice(-50);
+            return {
+                sentToday: this.emailMetrics.sentToday,
+                receivedToday: this.emailMetrics.receivedToday,
+                failedToday: this.emailMetrics.failedToday,
+                bounceRate: this.emailMetrics.bouncedToday > 0
+                    ? (this.emailMetrics.bouncedToday / this.emailMetrics.sentToday) * 100
+                    : 0,
+                deliveryRate: this.emailMetrics.sentToday > 0
+                    ? ((this.emailMetrics.sentToday - this.emailMetrics.failedToday) / this.emailMetrics.sentToday) * 100
+                    : 100,
+                queueSize: this.emailMetrics.queueSize,
+                averageDeliveryTime: Math.round(avgDeliveryTime),
+                topRecipients,
+                recentActivity,
+            };
+        });
+    }
+    // Get DNS metrics
+    async getDnsStats() {
+        return this.metricsCache.get('dnsStats', () => {
+            const cacheHitRate = this.dnsMetrics.totalQueries > 0
+                ? (this.dnsMetrics.cacheHits / this.dnsMetrics.totalQueries) * 100
+                : 0;
+            const topDomains = Array.from(this.dnsMetrics.topDomains.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 10)
+                .map(([domain, count]) => ({ domain, count }));
+            // Calculate queries per second from recent timestamps
+            const now = Date.now();
+            const oneMinuteAgo = now - 60000;
+            const recentQueries = this.dnsMetrics.queryTimestamps.filter(ts => ts >= oneMinuteAgo);
+            const queriesPerSecond = recentQueries.length / 60;
+            // Calculate average response time
+            const avgResponseTime = this.dnsMetrics.responseTimes.length > 0
+                ? this.dnsMetrics.responseTimes.reduce((a, b) => a + b, 0) / this.dnsMetrics.responseTimes.length
+                : 0;
+            return {
+                queriesPerSecond: Math.round(queriesPerSecond * 10) / 10,
+                totalQueries: this.dnsMetrics.totalQueries,
+                cacheHits: this.dnsMetrics.cacheHits,
+                cacheMisses: this.dnsMetrics.cacheMisses,
+                cacheHitRate: cacheHitRate,
+                topDomains: topDomains,
+                queryTypes: this.dnsMetrics.queryTypes,
+                averageResponseTime: Math.round(avgResponseTime),
+                activeDomains: this.dnsMetrics.topDomains.size,
+            };
+        });
+    }
+    // Get security metrics
+    async getSecurityStats() {
+        return this.metricsCache.get('securityStats', () => {
+            // Get recent incidents (last 20)
+            const recentIncidents = this.securityMetrics.incidents.slice(-20);
+            return {
+                blockedIPs: this.securityMetrics.blockedIPs,
+                authFailures: this.securityMetrics.authFailures,
+                spamDetected: this.securityMetrics.spamDetected,
+                malwareDetected: this.securityMetrics.malwareDetected,
+                phishingDetected: this.securityMetrics.phishingDetected,
+                totalThreatsBlocked: this.securityMetrics.spamDetected +
+                    this.securityMetrics.malwareDetected +
+                    this.securityMetrics.phishingDetected,
+                recentIncidents,
+            };
+        });
+    }
+    // Get connection info from SmartProxy
+    async getConnectionInfo() {
+        return this.metricsCache.get('connectionInfo', () => {
+            const proxyMetrics = this.dcRouter.smartProxy ? this.dcRouter.smartProxy.getMetrics() : null;
+            if (!proxyMetrics) {
+                return [];
+            }
+            const connectionsByRoute = proxyMetrics.connections.byRoute();
+            const connectionInfo = [];
+            for (const [routeName, count] of connectionsByRoute) {
+                connectionInfo.push({
+                    type: 'https',
+                    count,
+                    source: routeName,
+                    lastActivity: new Date(),
+                });
+            }
+            return connectionInfo;
+        });
+    }
+    // Email event tracking methods
+    trackEmailSent(recipient, deliveryTimeMs) {
+        this.emailMetrics.sentToday++;
+        if (recipient) {
+            const count = this.emailMetrics.recipients.get(recipient) || 0;
+            this.emailMetrics.recipients.set(recipient, count + 1);
+        }
+        if (deliveryTimeMs) {
+            this.emailMetrics.deliveryTimes.push(deliveryTimeMs);
+            // Keep only last 1000 delivery times
+            if (this.emailMetrics.deliveryTimes.length > 1000) {
+                this.emailMetrics.deliveryTimes.shift();
+            }
+        }
+        this.emailMetrics.recentActivity.push({
+            timestamp: Date.now(),
+            type: 'sent',
+            details: recipient || 'unknown',
+        });
+        // Keep only last 1000 activities
+        if (this.emailMetrics.recentActivity.length > 1000) {
+            this.emailMetrics.recentActivity.shift();
+        }
+    }
+    trackEmailReceived(sender) {
+        this.emailMetrics.receivedToday++;
+        this.emailMetrics.recentActivity.push({
+            timestamp: Date.now(),
+            type: 'received',
+            details: sender || 'unknown',
+        });
+        // Keep only last 1000 activities
+        if (this.emailMetrics.recentActivity.length > 1000) {
+            this.emailMetrics.recentActivity.shift();
+        }
+    }
+    trackEmailFailed(recipient, reason) {
+        this.emailMetrics.failedToday++;
+        this.emailMetrics.recentActivity.push({
+            timestamp: Date.now(),
+            type: 'failed',
+            details: `${recipient || 'unknown'}: ${reason || 'unknown error'}`,
+        });
+        // Keep only last 1000 activities
+        if (this.emailMetrics.recentActivity.length > 1000) {
+            this.emailMetrics.recentActivity.shift();
+        }
+    }
+    trackEmailBounced(recipient) {
+        this.emailMetrics.bouncedToday++;
+        this.emailMetrics.recentActivity.push({
+            timestamp: Date.now(),
+            type: 'bounced',
+            details: recipient || 'unknown',
+        });
+        // Keep only last 1000 activities
+        if (this.emailMetrics.recentActivity.length > 1000) {
+            this.emailMetrics.recentActivity.shift();
+        }
+    }
+    updateQueueSize(size) {
+        this.emailMetrics.queueSize = size;
+    }
+    // DNS event tracking methods
+    trackDnsQuery(queryType, domain, cacheHit, responseTimeMs) {
+        this.dnsMetrics.totalQueries++;
+        if (cacheHit) {
+            this.dnsMetrics.cacheHits++;
+        }
+        else {
+            this.dnsMetrics.cacheMisses++;
+        }
+        // Track query timestamp
+        this.dnsMetrics.queryTimestamps.push(Date.now());
+        // Keep only timestamps from last 5 minutes
+        const fiveMinutesAgo = Date.now() - 300000;
+        this.dnsMetrics.queryTimestamps = this.dnsMetrics.queryTimestamps.filter(ts => ts >= fiveMinutesAgo);
+        // Track response time if provided
+        if (responseTimeMs) {
+            this.dnsMetrics.responseTimes.push(responseTimeMs);
+            // Keep only last 1000 response times
+            if (this.dnsMetrics.responseTimes.length > 1000) {
+                this.dnsMetrics.responseTimes.shift();
+            }
+        }
+        // Track query types
+        this.dnsMetrics.queryTypes[queryType] = (this.dnsMetrics.queryTypes[queryType] || 0) + 1;
+        // Track top domains with size limit
+        const currentCount = this.dnsMetrics.topDomains.get(domain) || 0;
+        this.dnsMetrics.topDomains.set(domain, currentCount + 1);
+        // If we've exceeded the limit, remove the least accessed domains
+        if (this.dnsMetrics.topDomains.size > this.MAX_TOP_DOMAINS) {
+            // Convert to array, sort by count, and keep only top domains
+            const sortedDomains = Array.from(this.dnsMetrics.topDomains.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, Math.floor(this.MAX_TOP_DOMAINS * 0.8)); // Keep 80% to avoid frequent cleanup
+            // Clear and repopulate with top domains
+            this.dnsMetrics.topDomains.clear();
+            sortedDomains.forEach(([domain, count]) => {
+                this.dnsMetrics.topDomains.set(domain, count);
+            });
+        }
+    }
+    // Security event tracking methods
+    trackBlockedIP(ip, reason) {
+        this.securityMetrics.blockedIPs++;
+        this.securityMetrics.incidents.push({
+            timestamp: Date.now(),
+            type: 'ip_blocked',
+            severity: 'medium',
+            details: `IP ${ip || 'unknown'} blocked: ${reason || 'security policy'}`,
+        });
+        // Keep only last 1000 incidents
+        if (this.securityMetrics.incidents.length > 1000) {
+            this.securityMetrics.incidents.shift();
+        }
+    }
+    trackAuthFailure(username, ip) {
+        this.securityMetrics.authFailures++;
+        this.securityMetrics.incidents.push({
+            timestamp: Date.now(),
+            type: 'auth_failure',
+            severity: 'low',
+            details: `Authentication failed for ${username || 'unknown'} from ${ip || 'unknown'}`,
+        });
+        // Keep only last 1000 incidents
+        if (this.securityMetrics.incidents.length > 1000) {
+            this.securityMetrics.incidents.shift();
+        }
+    }
+    trackSpamDetected(sender) {
+        this.securityMetrics.spamDetected++;
+        this.securityMetrics.incidents.push({
+            timestamp: Date.now(),
+            type: 'spam_detected',
+            severity: 'low',
+            details: `Spam detected from ${sender || 'unknown'}`,
+        });
+        // Keep only last 1000 incidents
+        if (this.securityMetrics.incidents.length > 1000) {
+            this.securityMetrics.incidents.shift();
+        }
+    }
+    trackMalwareDetected(source) {
+        this.securityMetrics.malwareDetected++;
+        this.securityMetrics.incidents.push({
+            timestamp: Date.now(),
+            type: 'malware_detected',
+            severity: 'high',
+            details: `Malware detected from ${source || 'unknown'}`,
+        });
+        // Keep only last 1000 incidents
+        if (this.securityMetrics.incidents.length > 1000) {
+            this.securityMetrics.incidents.shift();
+        }
+    }
+    trackPhishingDetected(source) {
+        this.securityMetrics.phishingDetected++;
+        this.securityMetrics.incidents.push({
+            timestamp: Date.now(),
+            type: 'phishing_detected',
+            severity: 'high',
+            details: `Phishing attempt from ${source || 'unknown'}`,
+        });
+        // Keep only last 1000 incidents
+        if (this.securityMetrics.incidents.length > 1000) {
+            this.securityMetrics.incidents.shift();
+        }
+    }
+    // Get network metrics from SmartProxy
+    async getNetworkStats() {
+        // Use shorter cache TTL for network stats to ensure real-time updates
+        return this.metricsCache.get('networkStats', () => {
+            const proxyMetrics = this.dcRouter.smartProxy ? this.dcRouter.smartProxy.getMetrics() : null;
+            if (!proxyMetrics) {
+                return {
+                    connectionsByIP: new Map(),
+                    throughputRate: { bytesInPerSecond: 0, bytesOutPerSecond: 0 },
+                    topIPs: [],
+                    totalDataTransferred: { bytesIn: 0, bytesOut: 0 },
+                };
+            }
+            // Get metrics using the new API
+            const connectionsByIP = proxyMetrics.connections.byIP();
+            const instantThroughput = proxyMetrics.throughput.instant();
+            // Get throughput rate
+            const throughputRate = {
+                bytesInPerSecond: instantThroughput.in,
+                bytesOutPerSecond: instantThroughput.out
+            };
+            // Get top IPs
+            const topIPs = proxyMetrics.connections.topIPs(10);
+            // Get total data transferred
+            const totalDataTransferred = {
+                bytesIn: proxyMetrics.totals.bytesIn(),
+                bytesOut: proxyMetrics.totals.bytesOut()
+            };
+            return {
+                connectionsByIP,
+                throughputRate,
+                topIPs,
+                totalDataTransferred,
+            };
+        }, 200); // Use 200ms cache for more frequent updates
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.metricsmanager.js","sourceRoot":"","sources":["../../../ts/monitoring/classes.metricsmanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/monitoring/index.d.ts

@@ -0,0 +1 @@
+export * from './classes.metricsmanager.js';

package/dist_ts/monitoring/index.js

@@ -0,0 +1,2 @@
+export * from './classes.metricsmanager.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9tb25pdG9yaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkJBQTZCLENBQUMifQ==

package/dist_ts/opsserver/classes.opsserver.d.ts

@@ -1,9 +1,17 @@
 import type DcRouter from '../classes.dcrouter.js';
 import * as plugins from '../plugins.js';
+import * as handlers from './handlers/index.js';
 export declare class OpsServer {
     dcRouterRef: DcRouter;
     server: plugins.typedserver.utilityservers.UtilityWebsiteServer;
     typedrouter: plugins.typedrequest.TypedRouter;
+    adminHandler: handlers.AdminHandler;
+    private configHandler;
+    private logsHandler;
+    private securityHandler;
+    private statsHandler;
+    private radiusHandler;
+    private emailOpsHandler;
     constructor(dcRouterRefArg: DcRouter);
     start(): Promise<void>;
     /**

package/dist_ts/opsserver/classes.opsserver.js

@@ -1,9 +1,20 @@
 import * as plugins from '../plugins.js';
 import * as paths from '../paths.js';
+import * as handlers from './handlers/index.js';
 export class OpsServer {
+    dcRouterRef;
+    server;
+    // TypedRouter for OpsServer-specific handlers
+    typedrouter = new plugins.typedrequest.TypedRouter();
+    // Handler instances
+    adminHandler;
+    configHandler;
+    logsHandler;
+    securityHandler;
+    statsHandler;
+    radiusHandler;
+    emailOpsHandler;
     constructor(dcRouterRefArg) {
-        // TypedRouter for OpsServer-specific handlers
-        this.typedrouter = new plugins.typedrequest.TypedRouter();
         this.dcRouterRef = dcRouterRefArg;
         // Add our typedrouter to the dcRouter's main typedrouter
         this.dcRouterRef.typedrouter.addTypedRouter(this.typedrouter);
@@ -18,15 +29,23 @@ export class OpsServer {
         // Add the main dcRouter typedrouter to the server's typedrouter
         this.server.typedrouter.addTypedRouter(this.dcRouterRef.typedrouter);
         // Set up handlers
-        this.setupHandlers();
+        await this.setupHandlers();
         await this.server.start(3000);
     }
     /**
      * Set up all TypedRequest handlers
      */
-    setupHandlers() {
-        // Handler setup will be implemented next
-        // For now, just a placeholder to ensure the structure is correct
+    async setupHandlers() {
+        // Instantiate all handlers - they self-register with the typedrouter
+        this.adminHandler = new handlers.AdminHandler(this);
+        await this.adminHandler.initialize(); // JWT needs async initialization
+        this.configHandler = new handlers.ConfigHandler(this);
+        this.logsHandler = new handlers.LogsHandler(this);
+        this.securityHandler = new handlers.SecurityHandler(this);
+        this.statsHandler = new handlers.StatsHandler(this);
+        this.radiusHandler = new handlers.RadiusHandler(this);
+        this.emailOpsHandler = new handlers.EmailOpsHandler(this);
+        console.log('✅ OpsServer TypedRequest handlers initialized');
     }
     async stop() {
         if (this.server) {
@@ -34,4 +53,4 @@ export class OpsServer {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5vcHNzZXJ2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9vcHNzZXJ2ZXIvY2xhc3Nlcy5vcHNzZXJ2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxLQUFLLEtBQUssTUFBTSxhQUFhLENBQUM7QUFFckMsTUFBTSxPQUFPLFNBQVM7SUFPcEIsWUFBWSxjQUF3QjtRQUhwQyw4Q0FBOEM7UUFDdkMsZ0JBQVcsR0FBRyxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsV0FBVyxFQUFFLENBQUM7UUFHMUQsSUFBSSxDQUFDLFdBQVcsR0FBRyxjQUFjLENBQUM7UUFFbEMseURBQXlEO1FBQ3pELElBQUksQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDaEUsQ0FBQztJQUVNLEtBQUssQ0FBQyxLQUFLO1FBQ2hCLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxPQUFPLENBQUMsV0FBVyxDQUFDLGNBQWMsQ0FBQyxvQkFBb0IsQ0FBQztZQUN4RSxNQUFNLEVBQUUsV0FBVztZQUNuQixZQUFZLEVBQUUsSUFBSTtZQUNsQixRQUFRLEVBQUUsS0FBSyxDQUFDLFNBQVM7U0FDMUIsQ0FBQyxDQUFDO1FBRUgseURBQXlEO1FBQ3pELGdFQUFnRTtRQUNoRSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUVyRSxrQkFBa0I7UUFDbEIsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO1FBRXJCLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDaEMsQ0FBQztJQUVEOztPQUVHO0lBQ0ssYUFBYTtRQUNuQix5Q0FBeUM7UUFDekMsaUVBQWlFO0lBQ25FLENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSTtRQUNmLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ2hCLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUMzQixDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5vcHNzZXJ2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9vcHNzZXJ2ZXIvY2xhc3Nlcy5vcHNzZXJ2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxLQUFLLEtBQUssTUFBTSxhQUFhLENBQUM7QUFDckMsT0FBTyxLQUFLLFFBQVEsTUFBTSxxQkFBcUIsQ0FBQztBQUVoRCxNQUFNLE9BQU8sU0FBUztJQUNiLFdBQVcsQ0FBVztJQUN0QixNQUFNLENBQTBEO0lBRXZFLDhDQUE4QztJQUN2QyxXQUFXLEdBQUcsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBRTVELG9CQUFvQjtJQUNiLFlBQVksQ0FBd0I7SUFDbkMsYUFBYSxDQUF5QjtJQUN0QyxXQUFXLENBQXVCO0lBQ2xDLGVBQWUsQ0FBMkI7SUFDMUMsWUFBWSxDQUF3QjtJQUNwQyxhQUFhLENBQXlCO0lBQ3RDLGVBQWUsQ0FBMkI7SUFFbEQsWUFBWSxjQUF3QjtRQUNsQyxJQUFJLENBQUMsV0FBVyxHQUFHLGNBQWMsQ0FBQztRQUVsQyx5REFBeUQ7UUFDekQsSUFBSSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRU0sS0FBSyxDQUFDLEtBQUs7UUFDaEIsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLE9BQU8sQ0FBQyxXQUFXLENBQUMsY0FBYyxDQUFDLG9CQUFvQixDQUFDO1lBQ3hFLE1BQU0sRUFBRSxXQUFXO1lBQ25CLFlBQVksRUFBRSxJQUFJO1lBQ2xCLFFBQVEsRUFBRSxLQUFLLENBQUMsU0FBUztTQUMxQixDQUFDLENBQUM7UUFFSCx5REFBeUQ7UUFDekQsZ0VBQWdFO1FBQ2hFLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBRXJFLGtCQUFrQjtRQUNsQixNQUFNLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUUzQixNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRDs7T0FFRztJQUNLLEtBQUssQ0FBQyxhQUFhO1FBQ3pCLHFFQUFxRTtRQUNyRSxJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksUUFBUSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNwRCxNQUFNLElBQUksQ0FBQyxZQUFZLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQyxpQ0FBaUM7UUFFdkUsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLFFBQVEsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDdEQsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLFFBQVEsQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDbEQsSUFBSSxDQUFDLGVBQWUsR0FBRyxJQUFJLFFBQVEsQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDMUQsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLFFBQVEsQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDcEQsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLFFBQVEsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDdEQsSUFBSSxDQUFDLGVBQWUsR0FBRyxJQUFJLFFBQVEsQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFMUQsT0FBTyxDQUFDLEdBQUcsQ0FBQywrQ0FBK0MsQ0FBQyxDQUFDO0lBQy9ELENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSTtRQUNmLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ2hCLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUMzQixDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=

package/dist_ts/{ts/opsserver → opsserver}/handlers/admin.handler.d.ts

@@ -1,6 +1,6 @@
 import * as plugins from '../../plugins.js';
 import type { OpsServer } from '../classes.opsserver.js';
-import * as interfaces from '../../../ts_interfaces/index.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
 export interface IJwtData {
     userId: string;
     status: 'loggedIn' | 'loggedOut';