@serve.zone/dcrouter 8.1.0 → 9.1.0

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

@@ -0,0 +1,154 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export class RemoteIngressHandler {
+    opsServerRef;
+    typedrouter = new plugins.typedrequest.TypedRouter();
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        // Get all remote ingress edges
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getRemoteIngresses', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.remoteIngressManager;
+            if (!manager) {
+                return { edges: [] };
+            }
+            // Return edges without secrets, enriched with effective listen ports and breakdown
+            const edges = manager.getAllEdges().map((e) => {
+                const breakdown = manager.getPortBreakdown(e);
+                return {
+                    ...e,
+                    secret: '********', // Never expose secrets via API
+                    effectiveListenPorts: manager.getEffectiveListenPorts(e),
+                    manualPorts: breakdown.manual,
+                    derivedPorts: breakdown.derived,
+                };
+            });
+            return { edges };
+        }));
+        // Create a new remote ingress edge
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('createRemoteIngress', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.remoteIngressManager;
+            const tunnelManager = this.opsServerRef.dcRouterRef.tunnelManager;
+            if (!manager) {
+                return {
+                    success: false,
+                    edge: null,
+                };
+            }
+            const edge = await manager.createEdge(dataArg.name, dataArg.listenPorts || [], dataArg.tags, dataArg.autoDerivePorts ?? true);
+            // Sync allowed edges with the hub
+            if (tunnelManager) {
+                await tunnelManager.syncAllowedEdges();
+            }
+            return { success: true, edge };
+        }));
+        // Delete a remote ingress edge
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('deleteRemoteIngress', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.remoteIngressManager;
+            const tunnelManager = this.opsServerRef.dcRouterRef.tunnelManager;
+            if (!manager) {
+                return { success: false, message: 'RemoteIngress not configured' };
+            }
+            const deleted = await manager.deleteEdge(dataArg.id);
+            if (deleted && tunnelManager) {
+                await tunnelManager.syncAllowedEdges();
+            }
+            return {
+                success: deleted,
+                message: deleted ? undefined : 'Edge not found',
+            };
+        }));
+        // Update a remote ingress edge
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('updateRemoteIngress', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.remoteIngressManager;
+            const tunnelManager = this.opsServerRef.dcRouterRef.tunnelManager;
+            if (!manager) {
+                return { success: false, edge: null };
+            }
+            const edge = await manager.updateEdge(dataArg.id, {
+                name: dataArg.name,
+                listenPorts: dataArg.listenPorts,
+                autoDerivePorts: dataArg.autoDerivePorts,
+                enabled: dataArg.enabled,
+                tags: dataArg.tags,
+            });
+            if (!edge) {
+                return { success: false, edge: null };
+            }
+            // Sync allowed edges — ports, tags, or enabled may have changed
+            if (tunnelManager) {
+                await tunnelManager.syncAllowedEdges();
+            }
+            const breakdown = manager.getPortBreakdown(edge);
+            return {
+                success: true,
+                edge: {
+                    ...edge,
+                    secret: '********',
+                    effectiveListenPorts: manager.getEffectiveListenPorts(edge),
+                    manualPorts: breakdown.manual,
+                    derivedPorts: breakdown.derived,
+                },
+            };
+        }));
+        // Regenerate secret for an edge
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('regenerateRemoteIngressSecret', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.remoteIngressManager;
+            const tunnelManager = this.opsServerRef.dcRouterRef.tunnelManager;
+            if (!manager) {
+                return { success: false, secret: '' };
+            }
+            const secret = await manager.regenerateSecret(dataArg.id);
+            if (!secret) {
+                return { success: false, secret: '' };
+            }
+            // Sync allowed edges since secret changed
+            if (tunnelManager) {
+                await tunnelManager.syncAllowedEdges();
+            }
+            return { success: true, secret };
+        }));
+        // Get runtime status of all edges
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getRemoteIngressStatus', async (dataArg, toolsArg) => {
+            const tunnelManager = this.opsServerRef.dcRouterRef.tunnelManager;
+            if (!tunnelManager) {
+                return { statuses: [] };
+            }
+            return { statuses: tunnelManager.getEdgeStatuses() };
+        }));
+        // Get a connection token for an edge
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getRemoteIngressConnectionToken', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.remoteIngressManager;
+            if (!manager) {
+                return { success: false, message: 'RemoteIngress not configured' };
+            }
+            const edge = manager.getEdge(dataArg.edgeId);
+            if (!edge) {
+                return { success: false, message: 'Edge not found' };
+            }
+            if (!edge.enabled) {
+                return { success: false, message: 'Edge is disabled' };
+            }
+            const hubHost = dataArg.hubHost
+                || this.opsServerRef.dcRouterRef.options.remoteIngressConfig?.hubDomain;
+            if (!hubHost) {
+                return {
+                    success: false,
+                    message: 'No hub hostname configured. Set hubDomain in remoteIngressConfig or provide hubHost.',
+                };
+            }
+            const hubPort = this.opsServerRef.dcRouterRef.options.remoteIngressConfig?.tunnelPort ?? 8443;
+            const token = plugins.remoteingress.encodeConnectionToken({
+                hubHost,
+                hubPort,
+                edgeId: edge.id,
+                secret: edge.secret,
+            });
+            return { success: true, token };
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/opsserver/handlers/security.handler.d.ts

@@ -0,0 +1,11 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class SecurityHandler {
+    private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+    private collectSecurityMetrics;
+    private getActiveConnections;
+    private getRateLimitStatus;
+}

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

@@ -0,0 +1,232 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+import { MetricsManager } from '../../monitoring/index.js';
+export class SecurityHandler {
+    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() {
+        // Security Metrics Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getSecurityMetrics', async (dataArg, toolsArg) => {
+            const metrics = await this.collectSecurityMetrics();
+            return {
+                metrics: {
+                    blockedIPs: metrics.blockedIPs,
+                    reputationScores: metrics.reputationScores,
+                    spamDetected: metrics.spamDetection.detected,
+                    malwareDetected: metrics.malwareDetected,
+                    phishingDetected: metrics.phishingDetected,
+                    authenticationFailures: metrics.authFailures,
+                    suspiciousActivities: metrics.suspiciousActivities,
+                },
+                trends: dataArg.includeDetails ? {
+                    spam: metrics.trends.spam,
+                    malware: metrics.trends.malware,
+                    phishing: metrics.trends.phishing,
+                } : undefined,
+            };
+        }));
+        // Active Connections Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getActiveConnections', async (dataArg, toolsArg) => {
+            const connections = await this.getActiveConnections(dataArg.protocol, dataArg.state);
+            const connectionInfos = connections.map(conn => ({
+                id: conn.id,
+                remoteAddress: conn.source.ip,
+                localAddress: conn.destination.ip,
+                startTime: conn.startTime,
+                protocol: conn.type === 'http' ? 'https' : conn.type,
+                state: conn.status,
+                bytesReceived: Math.floor(conn.bytesTransferred / 2),
+                bytesSent: Math.floor(conn.bytesTransferred / 2),
+            }));
+            const summary = {
+                total: connectionInfos.length,
+                byProtocol: connectionInfos.reduce((acc, conn) => {
+                    acc[conn.protocol] = (acc[conn.protocol] || 0) + 1;
+                    return acc;
+                }, {}),
+                byState: connectionInfos.reduce((acc, conn) => {
+                    acc[conn.state] = (acc[conn.state] || 0) + 1;
+                    return acc;
+                }, {}),
+            };
+            return {
+                connections: connectionInfos,
+                summary,
+            };
+        }));
+        // Network Stats Handler - provides comprehensive network metrics
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getNetworkStats', async (dataArg, toolsArg) => {
+            // Get network stats from MetricsManager if available
+            if (this.opsServerRef.dcRouterRef.metricsManager) {
+                const networkStats = await this.opsServerRef.dcRouterRef.metricsManager.getNetworkStats();
+                // Convert per-IP throughput Map to serializable array
+                const throughputByIP = [];
+                if (networkStats.throughputByIP) {
+                    for (const [ip, tp] of networkStats.throughputByIP) {
+                        throughputByIP.push({ ip, in: tp.in, out: tp.out });
+                    }
+                }
+                return {
+                    connectionsByIP: Array.from(networkStats.connectionsByIP.entries()).map(([ip, count]) => ({ ip, count })),
+                    throughputRate: networkStats.throughputRate,
+                    topIPs: networkStats.topIPs,
+                    totalDataTransferred: networkStats.totalDataTransferred,
+                    throughputHistory: networkStats.throughputHistory || [],
+                    throughputByIP,
+                    requestsPerSecond: networkStats.requestsPerSecond || 0,
+                    requestsTotal: networkStats.requestsTotal || 0,
+                };
+            }
+            // Fallback if MetricsManager not available
+            return {
+                connectionsByIP: [],
+                throughputRate: { bytesInPerSecond: 0, bytesOutPerSecond: 0 },
+                topIPs: [],
+                totalDataTransferred: { bytesIn: 0, bytesOut: 0 },
+                throughputHistory: [],
+                throughputByIP: [],
+                requestsPerSecond: 0,
+                requestsTotal: 0,
+            };
+        }));
+        // Rate Limit Status Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getRateLimitStatus', async (dataArg, toolsArg) => {
+            const status = await this.getRateLimitStatus(dataArg.domain, dataArg.ip);
+            const limits = status.limits.map(limit => ({
+                domain: limit.identifier,
+                currentRate: limit.current,
+                limit: limit.limit,
+                remaining: limit.limit - limit.current,
+                resetTime: limit.resetAt,
+                blocked: limit.status === 'limited',
+            }));
+            return {
+                limits,
+                globalLimit: dataArg.includeBlocked ? {
+                    current: limits.reduce((sum, l) => sum + l.currentRate, 0),
+                    limit: 1000, // Global limit
+                    remaining: 1000 - limits.reduce((sum, l) => sum + l.currentRate, 0),
+                } : undefined,
+            };
+        }));
+    }
+    async collectSecurityMetrics() {
+        // Get metrics from MetricsManager if available
+        if (this.opsServerRef.dcRouterRef.metricsManager) {
+            const securityStats = await this.opsServerRef.dcRouterRef.metricsManager.getSecurityStats();
+            return {
+                blockedIPs: [], // TODO: Track actual blocked IPs
+                reputationScores: {},
+                spamDetection: {
+                    detected: securityStats.spamDetected,
+                    falsePositives: 0,
+                },
+                malwareDetected: securityStats.malwareDetected,
+                phishingDetected: securityStats.phishingDetected,
+                authFailures: securityStats.authFailures,
+                suspiciousActivities: 0,
+                trends: {
+                    spam: [],
+                    malware: [],
+                    phishing: [],
+                },
+            };
+        }
+        // Fallback if MetricsManager not available
+        return {
+            blockedIPs: [],
+            reputationScores: {},
+            spamDetection: {
+                detected: 0,
+                falsePositives: 0,
+            },
+            malwareDetected: 0,
+            phishingDetected: 0,
+            authFailures: 0,
+            suspiciousActivities: 0,
+            trends: {
+                spam: [],
+                malware: [],
+                phishing: [],
+            },
+        };
+    }
+    async getActiveConnections(protocol, state) {
+        const connections = [];
+        // Get connection info and network stats from MetricsManager if available
+        if (this.opsServerRef.dcRouterRef.metricsManager) {
+            const connectionInfo = await this.opsServerRef.dcRouterRef.metricsManager.getConnectionInfo();
+            const networkStats = await this.opsServerRef.dcRouterRef.metricsManager.getNetworkStats();
+            // Use IP-based connection data from the new metrics API
+            if (networkStats.connectionsByIP && networkStats.connectionsByIP.size > 0) {
+                let connIndex = 0;
+                const publicIp = this.opsServerRef.dcRouterRef.options.publicIp || 'server';
+                for (const [ip, count] of networkStats.connectionsByIP) {
+                    // Create a connection entry for each active IP connection
+                    for (let i = 0; i < Math.min(count, 5); i++) { // Limit to 5 connections per IP for UI performance
+                        connections.push({
+                            id: `conn-${connIndex++}`,
+                            type: 'http',
+                            source: {
+                                ip: ip,
+                                port: Math.floor(Math.random() * 50000) + 10000, // High port range
+                            },
+                            destination: {
+                                ip: publicIp,
+                                port: 443,
+                                service: 'proxy',
+                            },
+                            startTime: Date.now() - Math.floor(Math.random() * 3600000), // Within last hour
+                            bytesTransferred: Math.floor(networkStats.totalDataTransferred.bytesIn / networkStats.connectionsByIP.size),
+                            status: 'active',
+                        });
+                    }
+                }
+            }
+            else if (connectionInfo.length > 0) {
+                // Fallback to route-based connection info if no IP data available
+                connectionInfo.forEach((info, index) => {
+                    connections.push({
+                        id: `conn-${index}`,
+                        type: 'http',
+                        source: {
+                            ip: 'unknown',
+                            port: 0,
+                        },
+                        destination: {
+                            ip: this.opsServerRef.dcRouterRef.options.publicIp || 'server',
+                            port: 443,
+                            service: info.source,
+                        },
+                        startTime: info.lastActivity.getTime(),
+                        bytesTransferred: 0,
+                        status: 'active',
+                    });
+                });
+            }
+        }
+        // Filter by protocol if specified
+        if (protocol) {
+            return connections.filter(conn => {
+                if (protocol === 'https' || protocol === 'http') {
+                    return conn.type === 'http';
+                }
+                return conn.type === protocol.replace('s', ''); // smtp/smtps -> smtp
+            });
+        }
+        return connections;
+    }
+    async getRateLimitStatus(domain, ip) {
+        // TODO: Implement actual rate limit status collection
+        return {
+            limits: [],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security.handler.js","sourceRoot":"","sources":["../../../../ts/opsserver/handlers/security.handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/opsserver/handlers/stats.handler.d.ts

@@ -0,0 +1,13 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class StatsHandler {
+    private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+    private collectServerStats;
+    private collectEmailStats;
+    private collectDnsStats;
+    private getQueueStatus;
+    private checkHealthStatus;
+}