@serve.zone/dcrouter 9.1.0 → 9.1.1

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

@@ -0,0 +1,180 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export class AdminHandler {
+    opsServerRef;
+    typedrouter = new plugins.typedrequest.TypedRouter();
+    // JWT instance
+    smartjwtInstance;
+    // Simple in-memory user storage (in production, use proper database)
+    users = new Map();
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        // Add this handler's router to the parent
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+    }
+    async initialize() {
+        await this.initializeJwt();
+        this.initializeDefaultUsers();
+        this.registerHandlers();
+    }
+    async initializeJwt() {
+        this.smartjwtInstance = new plugins.smartjwt.SmartJwt();
+        await this.smartjwtInstance.init();
+        // For development, create new keypair each time
+        // In production, load from storage like cloudly does
+        await this.smartjwtInstance.createNewKeyPair();
+    }
+    initializeDefaultUsers() {
+        // Add default admin user
+        const adminId = plugins.uuid.v4();
+        this.users.set(adminId, {
+            id: adminId,
+            username: 'admin',
+            password: 'admin',
+            role: 'admin',
+        });
+    }
+    registerHandlers() {
+        // Admin Login Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('adminLoginWithUsernameAndPassword', async (dataArg) => {
+            try {
+                // Find user by username and password
+                let user = null;
+                for (const [_, userData] of this.users) {
+                    if (userData.username === dataArg.username && userData.password === dataArg.password) {
+                        user = userData;
+                        break;
+                    }
+                }
+                if (!user) {
+                    throw new plugins.typedrequest.TypedResponseError('login failed');
+                }
+                const expiresAtTimestamp = Date.now() + 3600 * 1000 * 24; // 24 hours
+                const jwt = await this.smartjwtInstance.createJWT({
+                    userId: user.id,
+                    status: 'loggedIn',
+                    expiresAt: expiresAtTimestamp,
+                });
+                return {
+                    identity: {
+                        jwt,
+                        userId: user.id,
+                        name: user.username,
+                        expiresAt: expiresAtTimestamp,
+                        role: user.role,
+                        type: 'user',
+                    },
+                };
+            }
+            catch (error) {
+                if (error instanceof plugins.typedrequest.TypedResponseError) {
+                    throw error;
+                }
+                throw new plugins.typedrequest.TypedResponseError('login failed');
+            }
+        }));
+        // Admin Logout Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('adminLogout', async (dataArg) => {
+            // In a real implementation, you might want to blacklist the JWT
+            // For now, just return success
+            return {
+                success: true,
+            };
+        }));
+        // Verify Identity Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('verifyIdentity', async (dataArg) => {
+            if (!dataArg.identity?.jwt) {
+                return {
+                    valid: false,
+                };
+            }
+            try {
+                const jwtData = await this.smartjwtInstance.verifyJWTAndGetData(dataArg.identity.jwt);
+                // Check if expired
+                if (jwtData.expiresAt < Date.now()) {
+                    return {
+                        valid: false,
+                    };
+                }
+                // Check if logged in
+                if (jwtData.status !== 'loggedIn') {
+                    return {
+                        valid: false,
+                    };
+                }
+                // Find user
+                const user = this.users.get(jwtData.userId);
+                if (!user) {
+                    return {
+                        valid: false,
+                    };
+                }
+                return {
+                    valid: true,
+                    identity: {
+                        jwt: dataArg.identity.jwt,
+                        userId: user.id,
+                        name: user.username,
+                        expiresAt: jwtData.expiresAt,
+                        role: user.role,
+                        type: 'user',
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    valid: false,
+                };
+            }
+        }));
+    }
+    /**
+     * Create a guard for valid identity (matching cloudly pattern)
+     */
+    validIdentityGuard = new plugins.smartguard.Guard(async (dataArg) => {
+        if (!dataArg.identity?.jwt) {
+            return false;
+        }
+        try {
+            const jwtData = await this.smartjwtInstance.verifyJWTAndGetData(dataArg.identity.jwt);
+            // Check expiration
+            if (jwtData.expiresAt < Date.now()) {
+                return false;
+            }
+            // Check status
+            if (jwtData.status !== 'loggedIn') {
+                return false;
+            }
+            // Verify data hasn't been tampered with
+            if (dataArg.identity.expiresAt !== jwtData.expiresAt) {
+                return false;
+            }
+            if (dataArg.identity.userId !== jwtData.userId) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }, {
+        failedHint: 'identity is not valid',
+        name: 'validIdentityGuard',
+    });
+    /**
+     * Create a guard for admin identity (matching cloudly pattern)
+     */
+    adminIdentityGuard = new plugins.smartguard.Guard(async (dataArg) => {
+        // First check if identity is valid
+        const isValid = await this.validIdentityGuard.exec(dataArg);
+        if (!isValid) {
+            return false;
+        }
+        // Check if user has admin role
+        return dataArg.identity.role === 'admin';
+    }, {
+        failedHint: 'user is not admin',
+        name: 'adminIdentityGuard',
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRtaW4uaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL29wc3NlcnZlci9oYW5kbGVycy9hZG1pbi5oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxLQUFLLFVBQVUsTUFBTSxpQ0FBaUMsQ0FBQztBQVE5RCxNQUFNLE9BQU8sWUFBWTtJQWNIO0lBYmIsV0FBVyxHQUFHLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUU1RCxlQUFlO0lBQ1IsZ0JBQWdCLENBQXNDO0lBRTdELHFFQUFxRTtJQUM3RCxLQUFLLEdBQUcsSUFBSSxHQUFHLEVBS25CLENBQUM7SUFFTCxZQUFvQixZQUF1QjtRQUF2QixpQkFBWSxHQUFaLFlBQVksQ0FBVztRQUN6QywwQ0FBMEM7UUFDMUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxXQUFXLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNqRSxDQUFDO0lBRU0sS0FBSyxDQUFDLFVBQVU7UUFDckIsTUFBTSxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7UUFDM0IsSUFBSSxDQUFDLHNCQUFzQixFQUFFLENBQUM7UUFDOUIsSUFBSSxDQUFDLGdCQUFnQixFQUFFLENBQUM7SUFDMUIsQ0FBQztJQUVPLEtBQUssQ0FBQyxhQUFhO1FBQ3pCLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDeEQsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLENBQUM7UUFFbkMsZ0RBQWdEO1FBQ2hELHFEQUFxRDtRQUNyRCxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0lBQ2pELENBQUM7SUFFTyxzQkFBc0I7UUFDNUIseUJBQXlCO1FBQ3pCLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLENBQUM7UUFDbEMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFO1lBQ3RCLEVBQUUsRUFBRSxPQUFPO1lBQ1gsUUFBUSxFQUFFLE9BQU87WUFDakIsUUFBUSxFQUFFLE9BQU87WUFDakIsSUFBSSxFQUFFLE9BQU87U0FDZCxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU8sZ0JBQWdCO1FBQ3RCLHNCQUFzQjtRQUN0QixJQUFJLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FDOUIsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FDbkMsbUNBQW1DLEVBQ25DLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRTtZQUNoQixJQUFJLENBQUM7Z0JBQ0gscUNBQXFDO2dCQUNyQyxJQUFJLElBQUksR0FBNEUsSUFBSSxDQUFDO2dCQUN6RixLQUFLLE1BQU0sQ0FBQyxDQUFDLEVBQUUsUUFBUSxDQUFDLElBQUksSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO29CQUN2QyxJQUFJLFFBQVEsQ0FBQyxRQUFRLEtBQUssT0FBTyxDQUFDLFFBQVEsSUFBSSxRQUFRLENBQUMsUUFBUSxLQUFLLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQzt3QkFDckYsSUFBSSxHQUFHLFFBQVEsQ0FBQzt3QkFDaEIsTUFBTTtvQkFDUixDQUFDO2dCQUNILENBQUM7Z0JBRUQsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO29CQUNWLE1BQU0sSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLGtCQUFrQixDQUFDLGNBQWMsQ0FBQyxDQUFDO2dCQUNwRSxDQUFDO2dCQUVELE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxHQUFHLElBQUksR0FBRyxJQUFJLEdBQUcsRUFBRSxDQUFDLENBQUMsV0FBVztnQkFFckUsTUFBTSxHQUFHLEdBQUcsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxDQUFDO29CQUNoRCxNQUFNLEVBQUUsSUFBSSxDQUFDLEVBQUU7b0JBQ2YsTUFBTSxFQUFFLFVBQVU7b0JBQ2xCLFNBQVMsRUFBRSxrQkFBa0I7aUJBQzlCLENBQUMsQ0FBQztnQkFFSCxPQUFPO29CQUNMLFFBQVEsRUFBRTt3QkFDUixHQUFHO3dCQUNILE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBRTt3QkFDZixJQUFJLEVBQUUsSUFBSSxDQUFDLFFBQVE7d0JBQ25CLFNBQVMsRUFBRSxrQkFBa0I7d0JBQzdCLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSTt3QkFDZixJQUFJLEVBQUUsTUFBTTtxQkFDYjtpQkFDRixDQUFDO1lBQ0osQ0FBQztZQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7Z0JBQ2YsSUFBSSxLQUFLLFlBQVksT0FBTyxDQUFDLFlBQVksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO29CQUM3RCxNQUFNLEtBQUssQ0FBQztnQkFDZCxDQUFDO2dCQUNELE1BQU0sSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLGtCQUFrQixDQUFDLGNBQWMsQ0FBQyxDQUFDO1lBQ3BFLENBQUM7UUFDSCxDQUFDLENBQ0YsQ0FDRixDQUFDO1FBRUYsdUJBQXVCO1FBQ3ZCLElBQUksQ0FBQyxXQUFXLENBQUMsZUFBZSxDQUM5QixJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUNuQyxhQUFhLEVBQ2IsS0FBSyxFQUFFLE9BQU8sRUFBRSxFQUFFO1lBQ2hCLGdFQUFnRTtZQUNoRSwrQkFBK0I7WUFDL0IsT0FBTztnQkFDTCxPQUFPLEVBQUUsSUFBSTthQUNkLENBQUM7UUFDSixDQUFDLENBQ0YsQ0FDRixDQUFDO1FBRUYsMEJBQTBCO1FBQzFCLElBQUksQ0FBQyxXQUFXLENBQUMsZUFBZSxDQUM5QixJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUNuQyxnQkFBZ0IsRUFDaEIsS0FBSyxFQUFFLE9BQU8sRUFBRSxFQUFFO1lBQ2hCLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLEdBQUcsRUFBRSxDQUFDO2dCQUMzQixPQUFPO29CQUNMLEtBQUssRUFBRSxLQUFLO2lCQUNiLENBQUM7WUFDSixDQUFDO1lBRUQsSUFBSSxDQUFDO2dCQUNILE1BQU0sT0FBTyxHQUFHLE1BQU0sSUFBSSxDQUFDLGdCQUFnQixDQUFDLG1CQUFtQixDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBRXRGLG1CQUFtQjtnQkFDbkIsSUFBSSxPQUFPLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDO29CQUNuQyxPQUFPO3dCQUNMLEtBQUssRUFBRSxLQUFLO3FCQUNiLENBQUM7Z0JBQ0osQ0FBQztnQkFFRCxxQkFBcUI7Z0JBQ3JCLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxVQUFVLEVBQUUsQ0FBQztvQkFDbEMsT0FBTzt3QkFDTCxLQUFLLEVBQUUsS0FBSztxQkFDYixDQUFDO2dCQUNKLENBQUM7Z0JBRUQsWUFBWTtnQkFDWixNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUM7Z0JBQzVDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztvQkFDVixPQUFPO3dCQUNMLEtBQUssRUFBRSxLQUFLO3FCQUNiLENBQUM7Z0JBQ0osQ0FBQztnQkFFRCxPQUFPO29CQUNMLEtBQUssRUFBRSxJQUFJO29CQUNYLFFBQVEsRUFBRTt3QkFDUixHQUFHLEVBQUUsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHO3dCQUN6QixNQUFNLEVBQUUsSUFBSSxDQUFDLEVBQUU7d0JBQ2YsSUFBSSxFQUFFLElBQUksQ0FBQyxRQUFRO3dCQUNuQixTQUFTLEVBQUUsT0FBTyxDQUFDLFNBQVM7d0JBQzVCLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSTt3QkFDZixJQUFJLEVBQUUsTUFBTTtxQkFDYjtpQkFDRixDQUFDO1lBQ0osQ0FBQztZQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7Z0JBQ2YsT0FBTztvQkFDTCxLQUFLLEVBQUUsS0FBSztpQkFDYixDQUFDO1lBQ0osQ0FBQztRQUNILENBQUMsQ0FDRixDQUNGLENBQUM7SUFDSixDQUFDO0lBRUQ7O09BRUc7SUFDSSxrQkFBa0IsR0FBRyxJQUFJLE9BQU8sQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUd0RCxLQUFLLEVBQUUsT0FBTyxFQUFFLEVBQUU7UUFDaEIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsR0FBRyxFQUFFLENBQUM7WUFDM0IsT0FBTyxLQUFLLENBQUM7UUFDZixDQUFDO1FBRUQsSUFBSSxDQUFDO1lBQ0gsTUFBTSxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsbUJBQW1CLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUV0RixtQkFBbUI7WUFDbkIsSUFBSSxPQUFPLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDO2dCQUNuQyxPQUFPLEtBQUssQ0FBQztZQUNmLENBQUM7WUFFRCxlQUFlO1lBQ2YsSUFBSSxPQUFPLENBQUMsTUFBTSxLQUFLLFVBQVUsRUFBRSxDQUFDO2dCQUNsQyxPQUFPLEtBQUssQ0FBQztZQUNmLENBQUM7WUFFRCx3Q0FBd0M7WUFDeEMsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVMsS0FBSyxPQUFPLENBQUMsU0FBUyxFQUFFLENBQUM7Z0JBQ3JELE9BQU8sS0FBSyxDQUFDO1lBQ2YsQ0FBQztZQUVELElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNLEtBQUssT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDO2dCQUMvQyxPQUFPLEtBQUssQ0FBQztZQUNmLENBQUM7WUFFRCxPQUFPLElBQUksQ0FBQztRQUNkLENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQ2YsT0FBTyxLQUFLLENBQUM7UUFDZixDQUFDO0lBQ0gsQ0FBQyxFQUNEO1FBQ0UsVUFBVSxFQUFFLHVCQUF1QjtRQUNuQyxJQUFJLEVBQUUsb0JBQW9CO0tBQzNCLENBQ0YsQ0FBQztJQUVGOztPQUVHO0lBQ0ksa0JBQWtCLEdBQUcsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FHdEQsS0FBSyxFQUFFLE9BQU8sRUFBRSxFQUFFO1FBQ2hCLG1DQUFtQztRQUNuQyxNQUFNLE9BQU8sR0FBRyxNQUFNLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDNUQsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ2IsT0FBTyxLQUFLLENBQUM7UUFDZixDQUFDO1FBRUQsK0JBQStCO1FBQy9CLE9BQU8sT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLEtBQUssT0FBTyxDQUFDO0lBQzNDLENBQUMsRUFDRDtRQUNFLFVBQVUsRUFBRSxtQkFBbUI7UUFDL0IsSUFBSSxFQUFFLG9CQUFvQjtLQUMzQixDQUNGLENBQUM7Q0FDSCJ9

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

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

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

@@ -0,0 +1,169 @@
+import * as plugins from '../../plugins.js';
+import * as paths from '../../paths.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export class ConfigHandler {
+    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 Configuration Handler (read-only)
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getConfiguration', async (dataArg, toolsArg) => {
+            const config = await this.getConfiguration();
+            return {
+                config,
+                section: dataArg.section,
+            };
+        }));
+    }
+    async getConfiguration() {
+        const dcRouter = this.opsServerRef.dcRouterRef;
+        const opts = dcRouter.options;
+        const resolvedPaths = dcRouter.resolvedPaths;
+        // --- System ---
+        const storageBackend = opts.storage?.readFunction
+            ? 'custom'
+            : opts.storage?.fsPath
+                ? 'filesystem'
+                : 'memory';
+        const system = {
+            baseDir: resolvedPaths.dcrouterHomeDir,
+            dataDir: resolvedPaths.dataDir,
+            publicIp: opts.publicIp || null,
+            proxyIps: opts.proxyIps || [],
+            uptime: Math.floor(process.uptime()),
+            storageBackend,
+            storagePath: opts.storage?.fsPath || null,
+        };
+        // --- SmartProxy ---
+        let acmeInfo = null;
+        if (opts.smartProxyConfig?.acme) {
+            const acme = opts.smartProxyConfig.acme;
+            acmeInfo = {
+                enabled: acme.enabled !== false,
+                accountEmail: acme.accountEmail || '',
+                useProduction: acme.useProduction !== false,
+                autoRenew: acme.autoRenew !== false,
+                renewThresholdDays: acme.renewThresholdDays || 30,
+            };
+        }
+        let routeCount = 0;
+        if (dcRouter.routeConfigManager) {
+            try {
+                const merged = await dcRouter.routeConfigManager.getMergedRoutes();
+                routeCount = merged.routes.length;
+            }
+            catch {
+                routeCount = opts.smartProxyConfig?.routes?.length || 0;
+            }
+        }
+        else if (opts.smartProxyConfig?.routes) {
+            routeCount = opts.smartProxyConfig.routes.length;
+        }
+        const smartProxy = {
+            enabled: !!dcRouter.smartProxy,
+            routeCount,
+            acme: acmeInfo,
+        };
+        // --- Email ---
+        let emailDomains = [];
+        if (dcRouter.emailServer && dcRouter.emailServer.domainRegistry) {
+            emailDomains = dcRouter.emailServer.domainRegistry.getAllDomains();
+        }
+        else if (opts.emailConfig?.domains) {
+            emailDomains = opts.emailConfig.domains.map((d) => typeof d === 'string' ? d : d.domain);
+        }
+        let portMapping = null;
+        if (opts.emailPortConfig?.portMapping) {
+            portMapping = {};
+            for (const [ext, int] of Object.entries(opts.emailPortConfig.portMapping)) {
+                portMapping[String(ext)] = int;
+            }
+        }
+        const email = {
+            enabled: !!dcRouter.emailServer,
+            ports: opts.emailConfig?.ports || [],
+            portMapping,
+            hostname: opts.emailConfig?.hostname || null,
+            domains: emailDomains,
+            emailRouteCount: opts.emailConfig?.routes?.length || 0,
+            receivedEmailsPath: opts.emailPortConfig?.receivedEmailsPath || null,
+        };
+        // --- DNS ---
+        const dnsRecords = (opts.dnsRecords || []).map(r => ({
+            name: r.name,
+            type: r.type,
+            value: r.value,
+            ttl: r.ttl,
+        }));
+        const dns = {
+            enabled: !!dcRouter.dnsServer,
+            port: 53,
+            nsDomains: opts.dnsNsDomains || [],
+            scopes: opts.dnsScopes || [],
+            recordCount: dnsRecords.length,
+            records: dnsRecords,
+            dnsChallenge: !!opts.dnsChallenge?.cloudflareApiKey,
+        };
+        // --- TLS ---
+        let tlsSource = 'none';
+        if (opts.tls?.certPath && opts.tls?.keyPath) {
+            tlsSource = 'static';
+        }
+        else if (opts.smartProxyConfig?.acme?.enabled !== false && opts.smartProxyConfig?.acme) {
+            tlsSource = 'acme';
+        }
+        const tls = {
+            contactEmail: opts.tls?.contactEmail || opts.smartProxyConfig?.acme?.accountEmail || null,
+            domain: opts.tls?.domain || null,
+            source: tlsSource,
+            certPath: opts.tls?.certPath || null,
+            keyPath: opts.tls?.keyPath || null,
+        };
+        // --- Cache ---
+        const cacheConfig = opts.cacheConfig;
+        const cache = {
+            enabled: cacheConfig?.enabled !== false,
+            storagePath: cacheConfig?.storagePath || resolvedPaths.defaultTsmDbPath,
+            dbName: cacheConfig?.dbName || 'dcrouter',
+            defaultTTLDays: cacheConfig?.defaultTTLDays || 30,
+            cleanupIntervalHours: cacheConfig?.cleanupIntervalHours || 1,
+            ttlConfig: cacheConfig?.ttlConfig ? { ...cacheConfig.ttlConfig } : {},
+        };
+        // --- RADIUS ---
+        const radiusCfg = opts.radiusConfig;
+        const radius = {
+            enabled: !!dcRouter.radiusServer,
+            authPort: radiusCfg?.authPort || null,
+            acctPort: radiusCfg?.acctPort || null,
+            bindAddress: radiusCfg?.bindAddress || null,
+            clientCount: radiusCfg?.clients?.length || 0,
+            vlanDefaultVlan: radiusCfg?.vlanAssignment?.defaultVlan ?? null,
+            vlanAllowUnknownMacs: radiusCfg?.vlanAssignment?.allowUnknownMacs ?? null,
+            vlanMappingCount: radiusCfg?.vlanAssignment?.mappings?.length || 0,
+        };
+        // --- Remote Ingress ---
+        const riCfg = opts.remoteIngressConfig;
+        const remoteIngress = {
+            enabled: !!dcRouter.remoteIngressManager,
+            tunnelPort: riCfg?.tunnelPort || null,
+            hubDomain: riCfg?.hubDomain || null,
+            tlsConfigured: !!(riCfg?.tls?.certPath && riCfg?.tls?.keyPath),
+        };
+        return {
+            system,
+            smartProxy,
+            email,
+            dns,
+            tls,
+            cache,
+            radius,
+            remoteIngress,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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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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"}