@serve.zone/dcrouter 8.1.0 → 9.1.1

package/dist_ts/opsserver/handlers/email-ops.handler.d.ts

@@ -0,0 +1,32 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class EmailOpsHandler {
+    private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+    /**
+     * Get all queue items mapped to catalog IEmail format
+     */
+    private getAllQueueEmails;
+    /**
+     * Get a single email detail by ID
+     */
+    private getEmailDetail;
+    /**
+     * Map a queue item to catalog IEmail format
+     */
+    private mapQueueItemToEmail;
+    /**
+     * Map a queue item to catalog IEmailDetail format
+     */
+    private mapQueueItemToEmailDetail;
+    /**
+     * Map queue status to catalog TEmailStatus
+     */
+    private mapStatus;
+    /**
+     * Format byte size to human-readable string
+     */
+    private formatSize;
+}

package/dist_ts/opsserver/handlers/email-ops.handler.js

@@ -0,0 +1,226 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export class EmailOpsHandler {
+    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() {
+        // Get All Emails Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getAllEmails', async (dataArg) => {
+            const emails = this.getAllQueueEmails();
+            return { emails };
+        }));
+        // Get Email Detail Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getEmailDetail', async (dataArg) => {
+            const email = this.getEmailDetail(dataArg.emailId);
+            return { email };
+        }));
+        // Resend Failed Email Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('resendEmail', async (dataArg) => {
+            const emailServer = this.opsServerRef.dcRouterRef.emailServer;
+            if (!emailServer?.deliveryQueue) {
+                return { success: false, error: 'Email server not available' };
+            }
+            const queue = emailServer.deliveryQueue;
+            const item = queue.getItem(dataArg.emailId);
+            if (!item) {
+                return { success: false, error: 'Email not found in queue' };
+            }
+            if (item.status !== 'failed') {
+                return { success: false, error: `Email is not in failed state (current: ${item.status})` };
+            }
+            try {
+                const newQueueId = await queue.enqueue(item.processingResult, item.processingMode, item.route);
+                await queue.removeItem(dataArg.emailId);
+                return { success: true, newQueueId };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to resend email'
+                };
+            }
+        }));
+    }
+    /**
+     * Get all queue items mapped to catalog IEmail format
+     */
+    getAllQueueEmails() {
+        const emailServer = this.opsServerRef.dcRouterRef.emailServer;
+        if (!emailServer?.deliveryQueue) {
+            return [];
+        }
+        const queue = emailServer.deliveryQueue;
+        const queueMap = queue.queue;
+        if (!queueMap) {
+            return [];
+        }
+        const emails = [];
+        for (const [id, item] of queueMap.entries()) {
+            emails.push(this.mapQueueItemToEmail(item));
+        }
+        // Sort by createdAt descending (newest first)
+        emails.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        return emails;
+    }
+    /**
+     * Get a single email detail by ID
+     */
+    getEmailDetail(emailId) {
+        const emailServer = this.opsServerRef.dcRouterRef.emailServer;
+        if (!emailServer?.deliveryQueue) {
+            return null;
+        }
+        const queue = emailServer.deliveryQueue;
+        const item = queue.getItem(emailId);
+        if (!item) {
+            return null;
+        }
+        return this.mapQueueItemToEmailDetail(item);
+    }
+    /**
+     * Map a queue item to catalog IEmail format
+     */
+    mapQueueItemToEmail(item) {
+        const processingResult = item.processingResult;
+        let from = '';
+        let to = '';
+        let subject = '';
+        let messageId = '';
+        let size = '0 B';
+        if (processingResult) {
+            if (processingResult.email) {
+                from = processingResult.email.from || '';
+                to = (processingResult.email.to || [])[0] || '';
+                subject = processingResult.email.subject || '';
+            }
+            else if (processingResult.from) {
+                from = processingResult.from;
+                to = (processingResult.to || [])[0] || '';
+                subject = processingResult.subject || '';
+            }
+            // Try to get messageId
+            if (typeof processingResult.getMessageId === 'function') {
+                try {
+                    messageId = processingResult.getMessageId() || '';
+                }
+                catch {
+                    messageId = '';
+                }
+            }
+            // Compute approximate size
+            const textLen = processingResult.text?.length || 0;
+            const htmlLen = processingResult.html?.length || 0;
+            let attachSize = 0;
+            if (typeof processingResult.getAttachmentsSize === 'function') {
+                try {
+                    attachSize = processingResult.getAttachmentsSize() || 0;
+                }
+                catch {
+                    attachSize = 0;
+                }
+            }
+            size = this.formatSize(textLen + htmlLen + attachSize);
+        }
+        // Map queue status to catalog TEmailStatus
+        const status = this.mapStatus(item.status);
+        const createdAt = item.createdAt instanceof Date ? item.createdAt.getTime() : item.createdAt;
+        return {
+            id: item.id,
+            direction: 'outbound',
+            status,
+            from,
+            to,
+            subject,
+            timestamp: new Date(createdAt).toISOString(),
+            messageId,
+            size,
+        };
+    }
+    /**
+     * Map a queue item to catalog IEmailDetail format
+     */
+    mapQueueItemToEmailDetail(item) {
+        const base = this.mapQueueItemToEmail(item);
+        const processingResult = item.processingResult;
+        let toList = [];
+        let cc = [];
+        let headers = {};
+        let body = '';
+        if (processingResult) {
+            if (processingResult.email) {
+                toList = processingResult.email.to || [];
+                cc = processingResult.email.cc || [];
+            }
+            else {
+                toList = processingResult.to || [];
+                cc = processingResult.cc || [];
+            }
+            headers = processingResult.headers || {};
+            body = processingResult.html || processingResult.text || '';
+        }
+        return {
+            ...base,
+            toList,
+            cc,
+            smtpLog: [],
+            connectionInfo: {
+                sourceIp: '',
+                sourceHostname: '',
+                destinationIp: '',
+                destinationPort: 0,
+                tlsVersion: '',
+                tlsCipher: '',
+                authenticated: false,
+                authMethod: '',
+                authUser: '',
+            },
+            authenticationResults: {
+                spf: 'none',
+                spfDomain: '',
+                dkim: 'none',
+                dkimDomain: '',
+                dmarc: 'none',
+                dmarcPolicy: '',
+            },
+            rejectionReason: item.status === 'failed' ? item.lastError : undefined,
+            bounceMessage: item.status === 'failed' ? item.lastError : undefined,
+            headers,
+            body,
+        };
+    }
+    /**
+     * Map queue status to catalog TEmailStatus
+     */
+    mapStatus(queueStatus) {
+        switch (queueStatus) {
+            case 'pending':
+            case 'processing':
+                return 'pending';
+            case 'delivered':
+                return 'delivered';
+            case 'failed':
+                return 'bounced';
+            case 'deferred':
+                return 'deferred';
+            default:
+                return 'pending';
+        }
+    }
+    /**
+     * Format byte size to human-readable string
+     */
+    formatSize(bytes) {
+        if (bytes < 1024)
+            return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(1)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"email-ops.handler.js","sourceRoot":"","sources":["../../../../ts/opsserver/handlers/email-ops.handler.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,17 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class LogsHandler {
+    private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+    private static mapLogLevel;
+    private static deriveCategory;
+    private getRecentLogs;
+    /**
+     * Add a log destination to the base logger that pushes entries
+     * to all connected ops_dashboard TypedSocket clients.
+     */
+    private setupLogPushDestination;
+    private setupLogStream;
+}

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

@@ -0,0 +1,215 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+import { logBuffer, baseLogger } from '../../logger.js';
+export class LogsHandler {
+    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();
+        this.setupLogPushDestination();
+    }
+    registerHandlers() {
+        // Get Recent Logs Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getRecentLogs', async (dataArg, toolsArg) => {
+            const logs = await this.getRecentLogs(dataArg.level, dataArg.category, dataArg.limit || 100, dataArg.offset || 0, dataArg.search, dataArg.timeRange);
+            return {
+                logs,
+                total: logs.length, // TODO: Implement proper total count
+                hasMore: false, // TODO: Implement proper pagination
+            };
+        }));
+        // Get Log Stream Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getLogStream', async (dataArg, toolsArg) => {
+            // Create a virtual stream for log streaming
+            const virtualStream = new plugins.typedrequest.VirtualStream();
+            // Set up log streaming
+            const streamLogs = this.setupLogStream(virtualStream, dataArg.filters?.level, dataArg.filters?.category, dataArg.follow);
+            // Start streaming
+            streamLogs.start();
+            // VirtualStream handles cleanup automatically
+            return {
+                logStream: virtualStream, // Cast to IVirtualStream interface
+            };
+        }));
+    }
+    static mapLogLevel(smartlogLevel) {
+        switch (smartlogLevel) {
+            case 'silly':
+            case 'debug':
+                return 'debug';
+            case 'warn':
+                return 'warn';
+            case 'error':
+                return 'error';
+            default:
+                return 'info';
+        }
+    }
+    static deriveCategory(zone, message) {
+        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';
+    }
+    async getRecentLogs(level, category, limit = 100, offset = 0, search, timeRange) {
+        // Compute a timestamp cutoff from timeRange
+        let since;
+        if (timeRange) {
+            const rangeMs = {
+                '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 = 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,
+            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 = [];
+        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;
+        }
+        return mapped;
+    }
+    /**
+     * Add a log destination to the base logger that pushes entries
+     * to all connected ops_dashboard TypedSocket clients.
+     */
+    setupLogPushDestination() {
+        const opsServerRef = this.opsServerRef;
+        baseLogger.addLogDestination({
+            async handleLog(logPackage) {
+                // Access the TypedSocket server instance from OpsServer
+                const typedsocket = opsServerRef.server?.typedserver?.typedsocket;
+                if (!typedsocket)
+                    return;
+                let connections;
+                try {
+                    connections = await typedsocket.findAllTargetConnectionsByTag('role', 'ops_dashboard');
+                }
+                catch {
+                    return;
+                }
+                if (connections.length === 0)
+                    return;
+                const entry = {
+                    timestamp: logPackage.timestamp || Date.now(),
+                    level: LogsHandler.mapLogLevel(logPackage.level),
+                    category: LogsHandler.deriveCategory(logPackage.context?.zone, logPackage.message),
+                    message: logPackage.message,
+                    metadata: logPackage.data,
+                };
+                for (const conn of connections) {
+                    try {
+                        const push = typedsocket.createTypedRequest('pushLogEntry', conn);
+                        push.fire({ entry }).catch(() => { }); // fire-and-forget
+                    }
+                    catch {
+                        // connection may have closed
+                    }
+                }
+            },
+        });
+    }
+    setupLogStream(virtualStream, levelFilter, categoryFilter, follow = true) {
+        let intervalId = null;
+        let logIndex = 0;
+        const start = () => {
+            if (!follow) {
+                // Send existing logs and close
+                this.getRecentLogs(levelFilter?.[0], categoryFilter?.[0], 100, 0).then(logs => {
+                    logs.forEach(log => {
+                        const logData = JSON.stringify(log);
+                        const encoder = new TextEncoder();
+                        virtualStream.sendData(encoder.encode(logData));
+                    });
+                    // VirtualStream doesn't have end() method - it closes automatically
+                });
+                return;
+            }
+            // For follow mode, simulate real-time log streaming
+            intervalId = setInterval(async () => {
+                const categories = ['smtp', 'dns', 'security', 'system', 'email'];
+                const levels = ['info', 'warn', 'error', 'debug'];
+                const mockCategory = categories[Math.floor(Math.random() * categories.length)];
+                const mockLevel = levels[Math.floor(Math.random() * levels.length)];
+                // Filter by requested criteria
+                if (levelFilter && !levelFilter.includes(mockLevel))
+                    return;
+                if (categoryFilter && !categoryFilter.includes(mockCategory))
+                    return;
+                const logEntry = {
+                    timestamp: Date.now(),
+                    level: mockLevel,
+                    category: mockCategory,
+                    message: `Real-time log ${logIndex++} from ${mockCategory}`,
+                    metadata: {
+                        requestId: plugins.uuid.v4(),
+                    },
+                };
+                const logData = JSON.stringify(logEntry);
+                const encoder = new TextEncoder();
+                try {
+                    await virtualStream.sendData(encoder.encode(logData));
+                }
+                catch {
+                    // Stream closed or errored — clean up to prevent interval leak
+                    clearInterval(intervalId);
+                    intervalId = null;
+                }
+            }, 2000); // Send a log every 2 seconds
+            // TODO: Hook into actual logger events
+            // logger.on('log', (logEntry) => {
+            //   if (matchesCriteria(logEntry, level, service)) {
+            //     virtualStream.sendData(formatLogEntry(logEntry));
+            //   }
+            // });
+        };
+        const stop = () => {
+            if (intervalId) {
+                clearInterval(intervalId);
+                intervalId = null;
+            }
+            // TODO: Unhook from logger events
+        };
+        return { start, stop };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logs.handler.js","sourceRoot":"","sources":["../../../../ts/opsserver/handlers/logs.handler.ts"],"names":[],"mappings":"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"}

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

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