@serve.zone/dcrouter 13.17.0 → 13.17.2

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

@@ -0,0 +1,25 @@
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class LogsHandler {
+    private opsServerRef;
+    private activeStreamStops;
+    constructor(opsServerRef: OpsServer);
+    /**
+     * Clean up all active log streams and deactivate the push destination.
+     * Called when OpsServer stops.
+     */
+    cleanup(): void;
+    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.
+     *
+     * Uses a module-level singleton so the destination is added only once,
+     * even across OpsServer restart cycles. The destination reads
+     * `currentOpsServerRef` dynamically so it always uses the active server.
+     */
+    private setupLogPushDestination;
+    private setupLogStream;
+}

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

@@ -0,0 +1,264 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+import { logBuffer, baseLogger } from '../../logger.js';
+// Module-level singleton: the log push destination is added once and reuses
+// the current OpsServer reference so it survives OpsServer restarts without
+// accumulating duplicate destinations.
+let logPushDestinationInstalled = false;
+let currentOpsServerRef = null;
+export class LogsHandler {
+    opsServerRef;
+    activeStreamStops = new Set();
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.registerHandlers();
+        this.setupLogPushDestination();
+    }
+    /**
+     * Clean up all active log streams and deactivate the push destination.
+     * Called when OpsServer stops.
+     */
+    cleanup() {
+        // Stop all active follow-mode log streams
+        for (const stop of this.activeStreamStops) {
+            stop();
+        }
+        this.activeStreamStops.clear();
+        // Deactivate the push destination (it stays registered but becomes a no-op)
+        currentOpsServerRef = null;
+    }
+    registerHandlers() {
+        // All log endpoints register directly on viewRouter (valid identity required via middleware)
+        const router = this.opsServerRef.viewRouter;
+        // Get Recent Logs Handler
+        router.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,
+                hasMore: false,
+            };
+        }));
+        // Get Log Stream Handler
+        router.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();
+            // Track the stop function so we can clean up on shutdown
+            this.activeStreamStops.add(streamLogs.stop);
+            return {
+                logStream: virtualStream,
+            };
+        }));
+    }
+    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.
+     *
+     * Uses a module-level singleton so the destination is added only once,
+     * even across OpsServer restart cycles. The destination reads
+     * `currentOpsServerRef` dynamically so it always uses the active server.
+     */
+    setupLogPushDestination() {
+        // Update the module-level reference so the existing destination uses the new server
+        currentOpsServerRef = this.opsServerRef;
+        if (logPushDestinationInstalled) {
+            return; // destination already registered — just updated the ref
+        }
+        logPushDestinationInstalled = true;
+        baseLogger.addLogDestination({
+            async handleLog(logPackage) {
+                const opsServer = currentOpsServerRef;
+                if (!opsServer)
+                    return;
+                const typedsocket = opsServer.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 stopped = false;
+        let lastTimestamp = Date.now();
+        const stop = () => {
+            stopped = true;
+            if (intervalId) {
+                clearInterval(intervalId);
+                intervalId = null;
+            }
+            this.activeStreamStops.delete(stop);
+        };
+        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));
+                    });
+                });
+                return;
+            }
+            // For follow mode, tail real log entries from the in-memory buffer
+            intervalId = setInterval(async () => {
+                if (stopped) {
+                    clearInterval(intervalId);
+                    intervalId = null;
+                    return;
+                }
+                // Fetch new entries since last poll
+                const rawEntries = logBuffer.getEntries({
+                    since: lastTimestamp,
+                    limit: 50,
+                });
+                if (rawEntries.length === 0)
+                    return;
+                for (const raw of rawEntries) {
+                    const mappedLevel = LogsHandler.mapLogLevel(raw.level);
+                    const mappedCategory = LogsHandler.deriveCategory(raw.context?.zone, raw.message);
+                    // Apply filters
+                    if (levelFilter && !levelFilter.includes(mappedLevel))
+                        continue;
+                    if (categoryFilter && !categoryFilter.includes(mappedCategory))
+                        continue;
+                    const logEntry = {
+                        timestamp: raw.timestamp || Date.now(),
+                        level: mappedLevel,
+                        category: mappedCategory,
+                        message: raw.message,
+                        metadata: raw.data,
+                    };
+                    const logData = JSON.stringify(logEntry);
+                    const encoder = new TextEncoder();
+                    try {
+                        let timeoutHandle;
+                        await Promise.race([
+                            virtualStream.sendData(encoder.encode(logData)).then((result) => {
+                                clearTimeout(timeoutHandle);
+                                return result;
+                            }),
+                            new Promise((_, reject) => {
+                                timeoutHandle = setTimeout(() => reject(new Error('stream send timeout')), 10_000);
+                            }),
+                        ]);
+                    }
+                    catch {
+                        // Stream closed, errored, or timed out — clean up
+                        stop();
+                        return;
+                    }
+                }
+                // Advance the watermark past all entries we just processed
+                const newest = rawEntries[rawEntries.length - 1];
+                if (newest.timestamp && newest.timestamp >= lastTimestamp) {
+                    lastTimestamp = newest.timestamp + 1;
+                }
+            }, 2000);
+        };
+        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/network-target.handler.d.ts

@@ -0,0 +1,10 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export declare class NetworkTargetHandler {
+    private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter<interfaces.typedrequestInterfaces.ITypedRequest>;
+    constructor(opsServerRef: OpsServer);
+    private requireAuth;
+    private registerHandlers;
+}

package/dist_ts/opsserver/handlers/network-target.handler.js

@@ -0,0 +1,117 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export class NetworkTargetHandler {
+    opsServerRef;
+    typedrouter = new plugins.typedrequest.TypedRouter();
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+    }
+    async requireAuth(request, requiredScope) {
+        if (request.identity?.jwt) {
+            try {
+                const isAdmin = await this.opsServerRef.adminHandler.adminIdentityGuard.exec({
+                    identity: request.identity,
+                });
+                if (isAdmin)
+                    return request.identity.userId;
+            }
+            catch { /* fall through */ }
+        }
+        if (request.apiToken) {
+            const tokenManager = this.opsServerRef.dcRouterRef.apiTokenManager;
+            if (tokenManager) {
+                const token = await tokenManager.validateToken(request.apiToken);
+                if (token) {
+                    if (!requiredScope || tokenManager.hasScope(token, requiredScope)) {
+                        return token.createdBy;
+                    }
+                    throw new plugins.typedrequest.TypedResponseError('insufficient scope');
+                }
+            }
+        }
+        throw new plugins.typedrequest.TypedResponseError('unauthorized');
+    }
+    registerHandlers() {
+        // Get all network targets
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getNetworkTargets', async (dataArg) => {
+            await this.requireAuth(dataArg, 'targets:read');
+            const resolver = this.opsServerRef.dcRouterRef.referenceResolver;
+            if (!resolver) {
+                return { targets: [] };
+            }
+            return { targets: resolver.listTargets() };
+        }));
+        // Get a single network target
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getNetworkTarget', async (dataArg) => {
+            await this.requireAuth(dataArg, 'targets:read');
+            const resolver = this.opsServerRef.dcRouterRef.referenceResolver;
+            if (!resolver) {
+                return { target: null };
+            }
+            return { target: resolver.getTarget(dataArg.id) || null };
+        }));
+        // Create a network target
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('createNetworkTarget', async (dataArg) => {
+            const userId = await this.requireAuth(dataArg, 'targets:write');
+            const resolver = this.opsServerRef.dcRouterRef.referenceResolver;
+            if (!resolver) {
+                return { success: false, message: 'Reference resolver not initialized' };
+            }
+            const id = await resolver.createTarget({
+                name: dataArg.name,
+                description: dataArg.description,
+                host: dataArg.host,
+                port: dataArg.port,
+                createdBy: userId,
+            });
+            return { success: true, id };
+        }));
+        // Update a network target
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('updateNetworkTarget', async (dataArg) => {
+            await this.requireAuth(dataArg, 'targets:write');
+            const resolver = this.opsServerRef.dcRouterRef.referenceResolver;
+            const manager = this.opsServerRef.dcRouterRef.routeConfigManager;
+            if (!resolver || !manager) {
+                return { success: false, message: 'Not initialized' };
+            }
+            const { affectedRouteIds } = await resolver.updateTarget(dataArg.id, {
+                name: dataArg.name,
+                description: dataArg.description,
+                host: dataArg.host,
+                port: dataArg.port,
+            });
+            if (affectedRouteIds.length > 0) {
+                await manager.reResolveRoutes(affectedRouteIds);
+            }
+            return { success: true, affectedRouteCount: affectedRouteIds.length };
+        }));
+        // Delete a network target
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('deleteNetworkTarget', async (dataArg) => {
+            await this.requireAuth(dataArg, 'targets:write');
+            const resolver = this.opsServerRef.dcRouterRef.referenceResolver;
+            const manager = this.opsServerRef.dcRouterRef.routeConfigManager;
+            if (!resolver || !manager) {
+                return { success: false, message: 'Not initialized' };
+            }
+            const result = await resolver.deleteTarget(dataArg.id, dataArg.force ?? false, manager.getRoutes());
+            if (result.success && dataArg.force) {
+                await manager.applyRoutes();
+            }
+            return result;
+        }));
+        // Get routes using a network target
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getNetworkTargetUsage', async (dataArg) => {
+            await this.requireAuth(dataArg, 'targets:read');
+            const resolver = this.opsServerRef.dcRouterRef.referenceResolver;
+            const manager = this.opsServerRef.dcRouterRef.routeConfigManager;
+            if (!resolver || !manager) {
+                return { routes: [] };
+            }
+            const usage = resolver.getTargetUsageForId(dataArg.id, manager.getRoutes());
+            return { routes: usage.map((u) => ({ id: u.id, name: u.routeName })) };
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,6 @@
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class RadiusHandler {
+    private opsServerRef;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+}