@serve.zone/dcrouter 7.0.1 → 7.2.0

package/dist_ts_web/elements/ops-view-security.js

@@ -291,6 +291,10 @@ let OpsViewSecurity = (() => {
         renderOverview(metrics) {
             const threatLevel = this.calculateThreatLevel(metrics);
             const threatScore = this.getThreatScore(metrics);
+            // Derive active sessions from recent successful auth events (last hour)
+            const allEvents = metrics.recentEvents || [];
+            const oneHourAgo = Date.now() - 3600000;
+            const recentAuthSuccesses = allEvents.filter((evt) => evt.type === 'authentication' && evt.success === true && evt.timestamp >= oneHourAgo).length;
             const tiles = [
                 {
                     id: 'threatLevel',
@@ -312,7 +316,7 @@ let OpsViewSecurity = (() => {
                 {
                     id: 'blockedThreats',
                     title: 'Blocked Threats',
-                    value: metrics.blockedIPs.length + metrics.spamDetected,
+                    value: (metrics.blockedIPs?.length || 0) + metrics.spamDetected,
                     type: 'number',
                     icon: 'lucide:ShieldCheck',
                     color: '#ef4444',
@@ -321,11 +325,11 @@ let OpsViewSecurity = (() => {
                 {
                     id: 'activeSessions',
                     title: 'Active Sessions',
-                    value: 0,
+                    value: recentAuthSuccesses,
                     type: 'number',
                     icon: 'lucide:Users',
                     color: '#22c55e',
-                    description: 'Current authenticated sessions',
+                    description: 'Authenticated in last hour',
                 },
                 {
                     id: 'authFailures',
@@ -387,6 +391,10 @@ let OpsViewSecurity = (() => {
     `;
         }
         renderAuthentication(metrics) {
+            // Derive auth events from recentEvents
+            const allEvents = metrics.recentEvents || [];
+            const authEvents = allEvents.filter((evt) => evt.type === 'authentication');
+            const successfulLogins = authEvents.filter((evt) => evt.success === true).length;
             const tiles = [
                 {
                     id: 'authFailures',
@@ -400,13 +408,21 @@ let OpsViewSecurity = (() => {
                 {
                     id: 'successfulLogins',
                     title: 'Successful Logins',
-                    value: 0,
+                    value: successfulLogins,
                     type: 'number',
                     icon: 'lucide:Lock',
                     color: '#22c55e',
                     description: 'Successful logins today',
                 },
             ];
+            // Map auth events to login history table data
+            const loginHistory = authEvents.map((evt) => ({
+                timestamp: evt.timestamp,
+                username: evt.details?.username || 'unknown',
+                ipAddress: evt.ipAddress || 'unknown',
+                success: evt.success ?? false,
+                reason: evt.success ? '' : evt.message || 'Authentication failed',
+            }));
             return html `
       <dees-statsgrid
         .tiles=${tiles}
@@ -417,7 +433,7 @@ let OpsViewSecurity = (() => {
       <dees-table
         .heading1=${'Login History'}
         .heading2=${'Recent authentication attempts'}
-        .data=${[]}
+        .data=${loginHistory}
         .displayFunction=${(item) => ({
                 'Time': new Date(item.timestamp).toLocaleString(),
                 'Username': item.username,
@@ -518,45 +534,35 @@ let OpsViewSecurity = (() => {
         getThreatScore(metrics) {
             // Simple scoring algorithm
             let score = 100;
-            score -= metrics.blockedIPs.length * 2;
-            score -= metrics.authenticationFailures * 1;
-            score -= metrics.spamDetected * 0.5;
-            score -= metrics.malwareDetected * 3;
-            score -= metrics.phishingDetected * 3;
-            score -= metrics.suspiciousActivities * 2;
+            const blockedCount = Array.isArray(metrics.blockedIPs) ? metrics.blockedIPs.length : (metrics.blockedIPs || 0);
+            score -= blockedCount * 2;
+            score -= (metrics.authenticationFailures || 0) * 1;
+            score -= (metrics.spamDetected || 0) * 0.5;
+            score -= (metrics.malwareDetected || 0) * 3;
+            score -= (metrics.phishingDetected || 0) * 3;
+            score -= (metrics.suspiciousActivities || 0) * 2;
             return Math.max(0, Math.min(100, Math.round(score)));
         }
         getSecurityEvents(metrics) {
-            // Mock data - in real implementation, this would come from the server
-            return [
-                {
-                    timestamp: Date.now() - 1000 * 60 * 5,
-                    event: 'Multiple failed login attempts',
-                    severity: 'warning',
-                    details: 'IP: 192.168.1.100',
-                },
-                {
-                    timestamp: Date.now() - 1000 * 60 * 15,
-                    event: 'SPF check failed',
-                    severity: 'medium',
-                    details: 'Domain: example.com',
-                },
-                {
-                    timestamp: Date.now() - 1000 * 60 * 30,
-                    event: 'IP blocked due to spam',
-                    severity: 'high',
-                    details: 'IP: 10.0.0.1',
-                },
-            ];
+            const events = metrics.recentEvents || [];
+            return events.map((evt) => ({
+                timestamp: evt.timestamp,
+                event: evt.message,
+                severity: evt.level === 'critical' ? 'critical' : evt.level === 'error' ? 'high' : evt.level === 'warn' ? 'warning' : 'info',
+                details: evt.ipAddress ? `IP: ${evt.ipAddress}` : evt.domain ? `Domain: ${evt.domain}` : evt.type,
+            }));
         }
         async clearBlockedIPs() {
-            console.log('Clear blocked IPs');
+            // SmartProxy manages IP blocking — not yet exposed via API
+            alert('Clearing blocked IPs is not yet supported from the UI.');
         }
         async unblockIP(ip) {
-            console.log('Unblock IP:', ip);
+            // SmartProxy manages IP blocking — not yet exposed via API
+            alert(`Unblocking IP ${ip} is not yet supported from the UI.`);
         }
         async saveEmailSecuritySettings() {
-            console.log('Save email security settings');
+            // Config is read-only from the UI for now
+            alert('Email security settings are read-only. Update the dcrouter configuration file to change these settings.');
         }
         static {
             __runInitializers(_classThis, _classExtraInitializers);
@@ -565,4 +571,4 @@ let OpsViewSecurity = (() => {
     return OpsViewSecurity = _classThis;
 })();
 export { OpsViewSecurity };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ops-view-security.js","sourceRoot":"","sources":["../../ts_web/elements/ops-view-security.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ops-view-security.js","sourceRoot":"","sources":["../../ts_web/elements/ops-view-security.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@serve.zone/dcrouter",
   "private": false,
-  "version": "7.0.1",
+  "version": "7.2.0",
   "description": "A multifaceted routing service handling mail and SMS delivery functions.",
   "type": "module",
   "exports": {
@@ -42,7 +42,7 @@
     "@push.rocks/smartfile": "^13.1.2",
     "@push.rocks/smartguard": "^3.1.0",
     "@push.rocks/smartjwt": "^2.2.1",
-    "@push.rocks/smartlog": "^3.1.11",
+    "@push.rocks/smartlog": "^3.2.1",
     "@push.rocks/smartmetrics": "^3.0.1",
     "@push.rocks/smartmongo": "^5.1.0",
     "@push.rocks/smartmta": "^5.2.2",

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '7.0.1',
+  version: '7.2.0',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }

package/ts/classes.dcrouter.ts

@@ -1055,7 +1055,25 @@ export class DcRouter {
     
     // Start the server
     await this.emailServer.start();
-    
+
+    // Wire delivery events to MetricsManager for time-series tracking
+    if (this.metricsManager && this.emailServer.deliverySystem) {
+      this.emailServer.deliverySystem.on('deliveryStart', (item: any) => {
+        this.metricsManager.trackEmailReceived(item?.from);
+      });
+      this.emailServer.deliverySystem.on('deliverySuccess', (item: any) => {
+        this.metricsManager.trackEmailSent(item?.to);
+      });
+      this.emailServer.deliverySystem.on('deliveryFailed', (item: any, error: any) => {
+        this.metricsManager.trackEmailFailed(item?.to, error?.message);
+      });
+    }
+    if (this.metricsManager && this.emailServer) {
+      this.emailServer.on('bounceProcessed', () => {
+        this.metricsManager.trackEmailBounced();
+      });
+    }
+
     logger.log('info', `Email server started on ports: ${emailConfig.ports.join(', ')}`);
   }
   

package/ts/logger.ts

@@ -1,5 +1,6 @@
 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';
@@ -10,6 +11,9 @@ const envMap: Record<string, 'local' | 'test' | 'staging' | 'production'> = {
   'production': 'production'
 };
 
+// In-memory log buffer for the OpsServer UI
+export const logBuffer = new SmartlogDestinationBuffer({ maxEntries: 2000 });
+
 // Default Smartlog instance
 const baseLogger = new plugins.smartlog.Smartlog({
   logContext: {
@@ -19,6 +23,9 @@ const baseLogger = new plugins.smartlog.Smartlog({
   }
 });
 
+// Wire the buffer destination so all logs are captured
+baseLogger.addLogDestination(logBuffer);
+
 // Extended logger compatible with the original enhanced logger API
 class StandardLogger {
   private defaultContext: Record<string, any> = {};

package/ts/monitoring/classes.metricsmanager.ts

@@ -1,6 +1,7 @@
 import * as plugins from '../plugins.js';
 import { DcRouter } from '../classes.dcrouter.js';
 import { MetricsCache } from './classes.metricscache.js';
+import { SecurityLogger, SecurityEventType } from '../security/classes.securitylogger.js';
 
 export class MetricsManager {
   private logger: plugins.smartlog.Smartlog;
@@ -37,6 +38,10 @@ export class MetricsManager {
     responseTimes: [] as number[], // Track response times in ms
   };
   
+  // Per-minute time-series buckets for charts
+  private emailMinuteBuckets = new Map<number, { sent: number; received: number; failed: number }>();
+  private dnsMinuteBuckets = new Map<number, { queries: number }>();
+
   // Track security-specific metrics
   private securityMetrics = {
     blockedIPs: 0,
@@ -227,20 +232,45 @@ export class MetricsManager {
     });
   }
   
+  /**
+   * Sync security metrics from the SecurityLogger singleton (last 24h).
+   * Called before returning security stats so counters reflect real events.
+   */
+  private syncFromSecurityLogger(): void {
+    try {
+      const securityLogger = SecurityLogger.getInstance();
+      const summary = securityLogger.getEventsSummary(86400000); // last 24h
+
+      this.securityMetrics.spamDetected = summary.byType[SecurityEventType.SPAM] || 0;
+      this.securityMetrics.malwareDetected = summary.byType[SecurityEventType.MALWARE] || 0;
+      this.securityMetrics.phishingDetected = summary.byType[SecurityEventType.DMARC] || 0; // phishing via DMARC
+      this.securityMetrics.authFailures =
+        summary.byType[SecurityEventType.AUTHENTICATION] || 0;
+      this.securityMetrics.blockedIPs =
+        (summary.byType[SecurityEventType.IP_REPUTATION] || 0) +
+        (summary.byType[SecurityEventType.REJECTED_CONNECTION] || 0);
+    } catch {
+      // SecurityLogger may not be initialized yet — ignore
+    }
+  }
+
   // Get security metrics
   public async getSecurityStats() {
     return this.metricsCache.get('securityStats', () => {
+      // Sync counters from the real SecurityLogger events
+      this.syncFromSecurityLogger();
+
       // 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 + 
+        totalThreatsBlocked: this.securityMetrics.spamDetected +
+          this.securityMetrics.malwareDetected +
           this.securityMetrics.phishingDetected,
         recentIncidents,
       };
@@ -275,6 +305,7 @@ export class MetricsManager {
   // Email event tracking methods
   public trackEmailSent(recipient?: string, deliveryTimeMs?: number): void {
     this.emailMetrics.sentToday++;
+    this.incrementEmailBucket('sent');
     
     if (recipient) {
       const count = this.emailMetrics.recipients.get(recipient) || 0;
@@ -311,6 +342,7 @@ export class MetricsManager {
   
   public trackEmailReceived(sender?: string): void {
     this.emailMetrics.receivedToday++;
+    this.incrementEmailBucket('received');
     
     this.emailMetrics.recentActivity.push({
       timestamp: Date.now(),
@@ -326,6 +358,7 @@ export class MetricsManager {
   
   public trackEmailFailed(recipient?: string, reason?: string): void {
     this.emailMetrics.failedToday++;
+    this.incrementEmailBucket('failed');
     
     this.emailMetrics.recentActivity.push({
       timestamp: Date.now(),
@@ -361,6 +394,7 @@ export class MetricsManager {
   // DNS event tracking methods
   public trackDnsQuery(queryType: string, domain: string, cacheHit: boolean, responseTimeMs?: number): void {
     this.dnsMetrics.totalQueries++;
+    this.incrementDnsBucket();
     
     if (cacheHit) {
       this.dnsMetrics.cacheHits++;
@@ -547,4 +581,90 @@ export class MetricsManager {
       };
     }, 200); // Use 200ms cache for more frequent updates
   }
+
+  // --- Time-series helpers ---
+
+  private static minuteKey(ts: number = Date.now()): number {
+    return Math.floor(ts / 60000) * 60000;
+  }
+
+  private incrementEmailBucket(field: 'sent' | 'received' | 'failed'): void {
+    const key = MetricsManager.minuteKey();
+    let bucket = this.emailMinuteBuckets.get(key);
+    if (!bucket) {
+      bucket = { sent: 0, received: 0, failed: 0 };
+      this.emailMinuteBuckets.set(key, bucket);
+    }
+    bucket[field]++;
+  }
+
+  private incrementDnsBucket(): void {
+    const key = MetricsManager.minuteKey();
+    let bucket = this.dnsMinuteBuckets.get(key);
+    if (!bucket) {
+      bucket = { queries: 0 };
+      this.dnsMinuteBuckets.set(key, bucket);
+    }
+    bucket.queries++;
+  }
+
+  private pruneOldBuckets(): void {
+    const cutoff = Date.now() - 86400000; // 24h
+    for (const key of this.emailMinuteBuckets.keys()) {
+      if (key < cutoff) this.emailMinuteBuckets.delete(key);
+    }
+    for (const key of this.dnsMinuteBuckets.keys()) {
+      if (key < cutoff) this.dnsMinuteBuckets.delete(key);
+    }
+  }
+
+  /**
+   * Get email time-series data for the last N hours, aggregated per minute.
+   */
+  public getEmailTimeSeries(hours: number = 24): {
+    sent: Array<{ timestamp: number; value: number }>;
+    received: Array<{ timestamp: number; value: number }>;
+    failed: Array<{ timestamp: number; value: number }>;
+  } {
+    this.pruneOldBuckets();
+    const cutoff = Date.now() - hours * 3600000;
+    const sent: Array<{ timestamp: number; value: number }> = [];
+    const received: Array<{ timestamp: number; value: number }> = [];
+    const failed: Array<{ timestamp: number; value: number }> = [];
+
+    const sortedKeys = Array.from(this.emailMinuteBuckets.keys())
+      .filter((k) => k >= cutoff)
+      .sort((a, b) => a - b);
+
+    for (const key of sortedKeys) {
+      const bucket = this.emailMinuteBuckets.get(key)!;
+      sent.push({ timestamp: key, value: bucket.sent });
+      received.push({ timestamp: key, value: bucket.received });
+      failed.push({ timestamp: key, value: bucket.failed });
+    }
+
+    return { sent, received, failed };
+  }
+
+  /**
+   * Get DNS time-series data for the last N hours, aggregated per minute.
+   */
+  public getDnsTimeSeries(hours: number = 24): {
+    queries: Array<{ timestamp: number; value: number }>;
+  } {
+    this.pruneOldBuckets();
+    const cutoff = Date.now() - hours * 3600000;
+    const queries: Array<{ timestamp: number; value: number }> = [];
+
+    const sortedKeys = Array.from(this.dnsMinuteBuckets.keys())
+      .filter((k) => k >= cutoff)
+      .sort((a, b) => a - b);
+
+    for (const key of sortedKeys) {
+      const bucket = this.dnsMinuteBuckets.get(key)!;
+      queries.push({ timestamp: key, value: bucket.queries });
+    }
+
+    return { queries };
+  }
 }

package/ts/opsserver/handlers/logs.handler.ts

@@ -1,6 +1,7 @@
 import * as plugins from '../../plugins.js';
 import type { OpsServer } from '../classes.opsserver.js';
 import * as interfaces from '../../../ts_interfaces/index.js';
+import { logBuffer } from '../../logger.js';
 
 export class LogsHandler {
   public typedrouter = new plugins.typedrequest.TypedRouter();
@@ -64,6 +65,32 @@ export class LogsHandler {
     );
   }
   
+  private static mapLogLevel(smartlogLevel: string): 'debug' | 'info' | 'warn' | 'error' {
+    switch (smartlogLevel) {
+      case 'silly':
+      case 'debug':
+        return 'debug';
+      case 'warn':
+        return 'warn';
+      case 'error':
+        return 'error';
+      default:
+        return 'info';
+    }
+  }
+
+  private static deriveCategory(
+    zone?: string,
+    message?: string
+  ): 'smtp' | 'dns' | 'security' | 'system' | 'email' {
+    const msg = (message || '').toLowerCase();
+    if (msg.includes('[security:') || msg.includes('security')) return 'security';
+    if (zone === 'email' || msg.includes('email') || msg.includes('smtp') || msg.includes('mta')) return 'email';
+    if (zone === 'dns' || msg.includes('dns')) return 'dns';
+    if (msg.includes('smtp')) return 'smtp';
+    return 'system';
+  }
+
   private async getRecentLogs(
     level?: 'error' | 'warn' | 'info' | 'debug',
     category?: 'smtp' | 'dns' | 'security' | 'system' | 'email',
@@ -78,42 +105,64 @@ export class LogsHandler {
     message: string;
     metadata?: any;
   }>> {
-    // TODO: Implement actual log retrieval from storage or logger
-    // For now, return mock data
-    const mockLogs: Array<{
+    // Compute a timestamp cutoff from timeRange
+    let since: number | undefined;
+    if (timeRange) {
+      const rangeMs: Record<string, number> = {
+        '1h': 3600000,
+        '6h': 21600000,
+        '24h': 86400000,
+        '7d': 604800000,
+        '30d': 2592000000,
+      };
+      since = Date.now() - (rangeMs[timeRange] || 86400000);
+    }
+
+    // Map the UI level to smartlog levels for filtering
+    const smartlogLevels: string[] | undefined = level
+      ? level === 'debug'
+        ? ['debug', 'silly']
+        : level === 'info'
+          ? ['info', 'ok', 'success', 'note', 'lifecycle']
+          : [level]
+      : undefined;
+
+    // Fetch a larger batch from buffer, then apply category filter client-side
+    const rawEntries = logBuffer.getEntries({
+      level: smartlogLevels as any,
+      search,
+      since,
+      limit: limit * 3, // over-fetch to compensate for category filtering
+      offset: 0,
+    });
+
+    // Map ILogPackage → UI log format and apply category filter
+    const mapped: Array<{
       timestamp: number;
       level: 'debug' | 'info' | 'warn' | 'error';
       category: 'smtp' | 'dns' | 'security' | 'system' | 'email';
       message: string;
       metadata?: any;
     }> = [];
-    
-    const categories: Array<'smtp' | 'dns' | 'security' | 'system' | 'email'> = ['smtp', 'dns', 'security', 'system', 'email'];
-    const levels: Array<'debug' | 'info' | 'warn' | 'error'> = ['info', 'warn', 'error', 'debug'];
-    const now = Date.now();
-    
-    // Generate some mock log entries
-    for (let i = 0; i < 50; i++) {
-      const mockCategory = categories[Math.floor(Math.random() * categories.length)];
-      const mockLevel = levels[Math.floor(Math.random() * levels.length)];
-      
-      // Filter by requested criteria
-      if (level && mockLevel !== level) continue;
-      if (category && mockCategory !== category) continue;
-      
-      mockLogs.push({
-        timestamp: now - (i * 60000), // 1 minute apart
-        level: mockLevel,
-        category: mockCategory,
-        message: `Sample log message ${i} from ${mockCategory}`,
-        metadata: {
-          requestId: plugins.uuid.v4(),
-        },
+
+    for (const pkg of rawEntries) {
+      const uiLevel = LogsHandler.mapLogLevel(pkg.level);
+      const uiCategory = LogsHandler.deriveCategory(pkg.context?.zone, pkg.message);
+
+      if (category && uiCategory !== category) continue;
+
+      mapped.push({
+        timestamp: pkg.timestamp,
+        level: uiLevel,
+        category: uiCategory,
+        message: pkg.message,
+        metadata: pkg.data,
       });
+
+      if (mapped.length >= limit) break;
     }
-    
-    // Apply pagination
-    return mockLogs.slice(offset, offset + limit);
+
+    return mapped;
   }
   
   private setupLogStream(